devbox
infabc
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

DP模型——状压DP

作者：infabc | 2024-01-31 14:40:01

赞

踩

状压dp

文章目录

前言

第200篇blog！好耶！

在之前发过一个状压DP的初步blog，现在回看发现上面写的好像不是那么的好，现在在这篇把状压再写出来。当然，是按照模型的关系循序渐进的

什么是状态压缩DP

我的理解就是用K进制来表示所要解决问题的状态的K种状态

基本例题1

蒙德里安的梦想

求把 N×M 的棋盘分割成若干个 1×2 的的长方形，有多少种方案。

例如当 N=2，M=4 时，共有 5 种方案。当 N=2，M=3时，共有 3 种方案。

参考：

https://lishizheng.blog.csdn.net/article/details/112706309

https://www.acwing.com/solution/content/28088/

前期思考

我们先放横着的，再放竖着的

那么总方案数等于只放横着的小方块的合法方案数

而什么叫合法，就是看每一列内部所有空着的连续方块的个数必须是偶数个，只有是偶数个才能保证竖着的才能完美填充进去

状态表示

f[i, j] 表示已经将前 i - 1列摆好，且从第 i - 1列，伸出到 i 列的状态是 j 的所有方案（第i列的状态是j）

注意这里的列的下标是从0开始的，所以也就是当前这列（第i-1列）摆好，延伸到下一列

j 是一个二进制数，它的二进制位为1表示对应位置的有方块，例如：

请添加图片描述

状态计算

伸到第 i 列的状态 j ，所以就是在对应的行上的第i - 1列放好了方块

在这里插入图片描述

状态表示的定义我们可以知道，在f[i, j]中我们表示转移过来的方案，那么他前面的所有可能的方案的和就是我们的f[i ,j]所存的值

我们可以考虑前一步操作，即 i - 2 列是怎么放的

这时候实际上由状态表示我们知道，从第 i - 1 列到第 i 列的放小方格的状态是固定的（j），那么我们可以考虑没有固定的，即前一列是怎么放的；所以我们根据这个状态来分割f[ i , j ]的方案能够做到不重不漏

设第 i - 2列伸到第 i - 1 列的状态是 k，当前状态是 j

首先我们可以很清楚的知道当只考虑前i - 2列的方案数就是f[i - 1, k]，但是这时候要考虑这时候的状态 k 能不能从第 i - 2 列伸到第 i - 1列呢？

前面我们已经分析了合法其一就是一列不能有奇数个空格；另一个就是看是不是前一列的方格有没有放过方块，因为前一列放过来就会引起我当前这列能不能放的问题；那么第 i - 1 列不会出现“打架”的情况就是当 j & k 为 0 的时候。

怎么理解为0呢？与运算的性质全1则1，j 状态与 k 状态对应的行上有1的结果产生就说明这一行两列都放方块了，显然是不合法的，所以我们应该让每一位二进制位结果都为0，所以答案最后就是0

那么怎么判断第一个全为偶数长度空格的情况呢？那么对于第 i - 1列来说，有了状态 k 和 j ，空着的状态是固定的了。因为状态表示的含义是我们前 i - 1列已经摆好了，不可能在动了。那么就是看第 i - 1列是不是能被竖着的空着的空格填满，那么我们放好第 i - 2列的时候，这时候的 i - 1 状态应该是 j | k。理解这个位运算也很简单，有插过来的就是1了。

关键是我想着上一段说的“这时候的 i - 1 状态”，可能会有歧义。但实际上不是的，我们再回过头去看定义，伸出到第 i 列的状态是 j ，所以 j 表示的是第 i 列的状态而不是第 i - 1列的状态，是第 i 列的状态 j 告诉了我们第 i - 1列是怎么新增方块的。

而答案最后就是f[m, 0]。我们下标是从0开始的，所以最后实际上应该是到m - 1列，m列不存在，而根据定义伸出到第m列的状态是0，即状态是没有方块伸出来。那么就是我们所要的答案

Code

// Problem: 蒙德里安的梦想
// Contest: AcWing
// URL: https://www.acwing.com/problem/content/293/
// Memory Limit: 64 MB
// Time Limit: 5000 ms
// Code by: ING__
//
// Powered by CP Editor (https://cpeditor.org)

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <sstream>
#define ll long long
#define re return
#define Endl "\n"
#define endl "\n"

using namespace std;

const int M = (1 << 12) + 10;
const int N = 11 + 10;

int n, m;
ll f[N][M];
bool st[M];

int main()
{

    while (cin >> n >> m, n || m)
    {
        for(int i = 0; i < 1 << n; i++){ // 预处理每一列的每一种情况是否合法
            int cnt = 0;
            st[i] = 1;
            for(int j = 0; j < n; j++){
                if(i >> j & 1){ // 每一个状态的可能性的每一列所有连续的空着的小方块
                    if(cnt % 2 == 1) st[i] = 0;
                    cnt = 0;
                }
                else cnt++;
            }
            if(cnt % 2 == 1) st[i] = 0; //最下面的那一段判断一下连续的0的个数!
        }

        memset(f, 0, sizeof f);
        f[0][0] = 1; // 初始化！
        // 没有第-1列存在，所以根
        据定义伸到第0列的状态是0方案数就是1，相当于空棋盘是一种方案

        for (int i = 1; i <= m; i++)
        {
            for (int j = 0; j < (1 << n); j++) // 当前列的状态
            {
                // f[i][j] = 0;
                for (int k = 0; k < (1 << n); k++) // 上一列的状态
                {
                    if (((j & k) == 0) && (st[j | k])) // 第i-2列的伸出来的和第i-1列伸出来的是不是冲突的，合法的
                    {
                        f[i][j] += f[i - 1][k];
                    }
                }
            }
        }

        cout << f[m][0] << endl;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76

基本例题2

最短Hamilton路径

给定一张 n 个点的带权无向图，点从 0∼n−1 标号，求起点 0 到终点 n−1 的最短 Hamilton 路径。

Hamilton 路径的定义是从 0 到 n−1 不重不漏地经过每个点恰好一次。

前期思考

题目要求的是确定了起点和终点，经过所有的点并且最后的最短距离是多少

如果暴力来做我们要枚举所有的可能性时间复杂度到了 ( n − 2 ) ! ∗ n (n-2)!*n (n−2)!∗n（我认为是）

我们来用状压DP来做

状态表示

f[i, j] 表示所有从0走到 j ，走过所有点是 i 的所有路径的距离（i 的路径表示包括 j 点）

i 用二进制表示对应的每一个点是不是走过了

状态计算

我们考虑前一个点，假设为k

那么距离就是从 0 走到 k 再加上从 k 到 j 的距离来更新，注意从0走到k要的路径要与从 0 走到 j 的路径减去 i 才行

k - > j 的距离是固定的，所以我只需要让前面最小就可以了

那么公式应该为
f [ i ] [ j ] = m i n ( f [ i ] [ j ] , f [ i − ( 1 < < j ) ] [ k ] + w [ k ] [ j ] ) f[i][j]= min(f[i][j],f[i - (1 <<j)][k] + w[k][j]) f[i][j]=min(f[i][j],f[i−(1<<j)][k]+w[k][j])
从而时间复杂度降低为 2 n ∗ n 2 2^n*n^2 2n∗n2

Code

// Problem: 最短Hamilton路径
// Contest: AcWing
// URL: https://www.acwing.com/problem/content/description/93/
// Memory Limit: 256 MB
// Time Limit: 5000 ms
// Code by: ING__
// 
// Edited on 2021-08-05 09:06:15

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;

int n;
int f[(int)((1 << 20) + 5)][25];
int w[25][25];

int main(){
	cin >> n;
	for(int i = 0; i < n; i++){
		for(int j = 0; j < n; j++){
			cin >> w[i][j];
		}
	}
	
	memset(f, 0x3f, sizeof(f)); // 没更新是不合法的
	f[1][0] = 0; // 初始化，考虑定义，到达第0个点的二进制路径是1，花费为0
	
	for(int i = 0; i < (1 << n); i++){
		for(int j = 0; j < n; j++){
			if((i >> j) & 1){
				for(int k = 0; k < n; k++){
					if((i >> k) & 1){
						f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);
					}
				}
			}
		}
	}
	
	cout << f[(1 << n) - 1][n - 1];
	
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

扩展

基于状态压缩两种常见的模型：棋盘式（基于连通性）和集合两种类型

棋盘式的例题就是上面的例题1，蒙德里安的梦想。可以想一下，从意纵横状态转移到了另一种上去

而集合类型的就是例题2，用二进制集合表示路径

棋盘式

小国王

在 n×n 的棋盘上放 k 个国王，国王可攻击相邻的 8 个格子，求使它们无法互相攻击的方案总数。

思考

由于每一个国王只能影响上下左右斜着8个方向的长度为1的区域，所以我们可以考虑当前这一行的前一行的状态，只有前一行才会影响当前行的放置的可行性。把 i 行看成若干个集合

状态表示

f[i ,j ,s]表示所有只摆放前 i 行，已经摆了 j 个国王，且第 i 行的状态是 s 的所有方案集合

状态计算

我们考虑上一行，即 i - 1行的状态

首先一行内，不能相邻

其次两行直接不能攻击到

那么怎么实现这两个效果呢？

设第 i 行的状态是 a，第 i - 1 行的状态是 b

首先两行的对应列是不能有国王的，那么a & b 肯定要等于0的

其次不能斜着有国王，我们排除掉正方向不能有国王后，(a | b)中不能有连续的1
f [ i ] [ j ] [ a ] = ∑ f [ i ] [ j − c o u n t ( a ) ] [ b ] f[i][j][a]=\sum f[i][j - count(a)][b] f[i][j][a]=∑f[i][j−count(a)][b]
DP时间复杂度：状态数量 * 状态计算的计算量

这题这样过来复杂度是 10 ∗ 100 ∗ 2 10 10 * 100 * 2^{10} 10∗100∗210约等于 1 0 9 10^9 109，好像不能过，但是不是每一种情况都是合法的，所以是一定不会达到这个复杂度

Code
// Problem: 小国王
// Contest: AcWing
// URL: https://www.acwing.com/problem/content/1066/
// Memory Limit: 64 MB
// Time Limit: 1000 ms
// Code by: ING__
// 
// Edited on 2021-08-05 10:07:04

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <sstream>
#define ll long long
#define re return
#define Endl "\n"
#define endl "\n"
#define pb push_back

using namespace std;

typedef pair<int, int> PII;

int dx[4] = {-1,0,1,0};
int dy[4] = {0,1,0,-1};

const int N = 12; // 扩容别太大
const int M = 110;
const int K = (1 << N);

int n, m;
ll f[N][M][K];
// 定义：前i行，已经摆了j个国王，且第i行的状态是k

vector<int> stats;
vector<int> head[K];
int cnt[K]; // 每个合法的状态对应的有几个1

bool check(int x){ // 检查连续1
	for(int i = 0; i < n - 1; i++){
		if(((x >> i) & 1) && ((x >> (i + 1)) & 1))
			return 0;
	}
	return 1;
}

void init(){ // 预处理
	for(int i = 0; i < (1 << n); i++){ // 预处理每一种可能的情况是否合法
		if(check(i)){ // 首先得满足当前自己行是没有相邻的
			stats.pb(i);
			cnt[i] = __builtin_popcount(i); // 看二进制有多少个1
		}
	}
	
	for(int i = 0; i < stats.size(); i++){ // 看一行内合法的数据之间如果做转移能不能行
		for(int j = 0; j < stats.size(); j++){
			int a = stats[i];
			int b = stats[j];
			if(((a & b) == 0) && check(a | b)){
				head[i].pb(j);
			}
		}
	}
}

int main(){
	cin >> n >> m;
	init();
	
	f[0][0][0] = 1; // 初始化
	for(int i = 1; i <= n + 1; i++){ // 这里为什么要写 n + 1是有巧妙的解法的，详情请看下放解释
		for(int j = 0; j <= m; j++){
			for(int x = 0; x < stats.size(); x++){
				for(int y = 0; y < head[x].size(); y++){
					int c = cnt[stats[x]];
					if(j >= c){
						f[i][j][stats[x]] += f[i - 1][j - c][stats[head[x][y]]];
					}
				}
			}
		}
	}
	
	cout << f[n + 1][m][0];
    /*
    我们考虑集合的定义，相当于我们在n+1行前用了全部的棋子所有的已经摆好了
    但最后一行(n+1行)内没有摆任何一个棋子，那么也就满足了题意
    如果用n的话，这样也是可以的：
    ll ans = 0;
	for(int i = 0; i < (1 << n); i++){
		ans += f[n][m][i];
	}
	
	cout << ans;
	*/
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104

玉米田

农夫约翰的土地由 M×N 个小方格组成，现在他要在土地里种植玉米。

非常遗憾，部分土地是不育的，无法种植。

而且，相邻的土地不能同时种植玉米，也就是说种植玉米的所有方格之间都不会有公共边缘。

现在给定土地的大小，请你求出共有多少种种植方法。

土地上什么都不种也算一种方法。

前期思考

这道题实际上与前面哪道题是一样的，代码搬过来改一改就行

状态表示

f[i , s] 表示只摆放前 i 行，第 i 行的状态为 s 的方案是多少

状态计算

详情可直接参照上一题的计算方式

Code
// Problem: 玉米田
// Contest: AcWing
// URL: https://www.acwing.com/problem/content/329/
// Memory Limit: 64 MB
// Time Limit: 1000 ms
// Code by: ING__
// 
// Edited on 2021-08-05 15:12:48

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#include <vector>
#define ll long long
#define pb push_back
#define re return
#define Endl "\n"
#define endl "\n"

using namespace std;

const int N = 13;
const int M = (1 << N);
const int mod = 1e8;

int g[N];
int n, m;
vector<int> stats;
vector<int> head[M];
int f[N][M];

bool check(int x){
	for(int i = 0; i < m; i++){ // 一行的每种状态
		if(((x >> i) & 1) && ((x >> (i + 1)) & 1))
			return 0;
	}
	return 1;
}

void init(){
	for(int i = 0; i < (1 << m); i++){ // 一行的每种状态，一行有m位
		if(check(i)){
			stats.pb(i);
		}
	}
	
	for(int i = 0; i < stats.size(); i++){
		for(int j = 0; j < stats.size(); j++){
			int a = stats[i];
			int b = stats[j];
			if((a & b) == 0){
				head[i].pb(j);
			}
		}
	}
}

int main(){
	cin >> n >> m;
	init();
	for(int i = 1; i <= n; i++){
		for(int j = 0; j < m; j++){
			int t;
			cin >> t;
			g[i] += (!t << j); // 用1表示不能放玉米，为了后面好进行位运算
		}
	}
	
	f[0][0] = 1; // 初始化，什么都不种也算一种方法
	
	for(int i = 1; i <= n + 1; i++){
		for(int x = 0; x < stats.size(); x++){
			for(int y = 0; y < head[x].size(); y++){
				int a = stats[x];
				int b = stats[head[x][y]];
				
				if(g[i] & a) continue;
				/*
				因为上面我们用的是1来表示的不能放，而我们状态中用1表示的是能放，
				那么两种状态表示的方法按位与运算得出来的的结果只要有1就说明实际上是冲突的，是不合法的
				*/
				f[i][a] = (f[i][a] + f[i - 1][b]) % mod;
			}
		}
	}
	
	cout << f[n + 1][0];
	
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93

炮兵阵地

炮兵只能部署在平原，攻击范围为上下左右扩展两格，攻击范围不受地形影响。在任意两支炮兵部队不在其攻击范围内，在地图最多能部署多少支部队

思考

这个题相较于玉米田区别在于范围增加了一格

那么考虑一格摆放的问题不仅要考虑上一行的关系还要考虑上两行的关系

那么我们这时候就可以想到不仅要枚举上一行的状态，还要枚举上两行的状态，在动规中多加一维

状态表示

f[ i, a, b] 表示只摆前 i 行，且第 i 行的状态是 a，第 i - 1行的状态是 b

状态计算

我们根据倒数第二行的状态（s）来计算

我们要满足：

  1. 首先要满足自己当前行的状态一行是合法的，那么还是不能出现
    • 两格范围内不能出现1
  2. 状态表示的邻着的两行也要是合法的
    • 两行的状态与运算结果是0
  3. 每一行的状态要与对应的地图的状态是合法的
    • (g[i] & a) && (g[i - 1] & b)
    • (i >= 2) && (g[i - 2] & c)
Code
// Problem: 炮兵阵地
// Contest: AcWing
// URL: https://www.acwing.com/problem/content/294/
// Memory Limit: 64 MB
// Time Limit: 1000 ms
// Code by: ING__
// 
// Edited on 2021-08-06 11:05:05

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <sstream>
#define ll long long
#define re return
#define Endl "\n"
#define endl "\n"
#define pb push_back

using namespace std;

const int N = 110;
const int M = 15;
const int K = 1 << 11;

int n, m;
vector<int> stats;
int cnt[K];
int g[N];
int f[2][K][K];

bool check(int x){
	for(int i = 0; i < m; i++){
		if(((x >> i) & 1) && (((x >> (i + 1)) & 1) || (x >> (i + 2) & 1))) // 注意运算优先级！！！
			return 0;
	}
	return 1;
}

void init(){
	for(int i = 0; i < (1 << m); i++){
		if(check(i)){
			stats.pb(i);
			cnt[i] = __builtin_popcount(i);
		}
	}
}

int main(){
	cin >> n >> m;
	for(int i = 1; i <= n; i++){
		for(int j = 0; j < m; j++){
			char c;
			cin >> c;
			if(c == 'H') g[i] += (1 << j); // 与上题一样
		}
	}
	
	init();
	
	for(int i = 1; i <= n; i++){
		for(int x = 0; x < stats.size(); x++){
			for(int y = 0; y < stats.size(); y++){
				for(int z = 0; z < stats.size(); z++){
					
					int a = stats[x]; // i
					int b = stats[y]; // i - 1
					int c = stats[z]; // i - 2
					
					if((a & b) || (a & c) || (c & b)) continue;
					if((g[i] & a) || (g[i - 1] & b)) continue;
					if(i >= 2 && (g[i - 2] & c)) continue; // 判断
					
					f[i & 1][a][b] = max(f[i & 1][a][b], f[(i - 1) & 1][b][c] + cnt[a]); // 滚动数组优化，更新只需要两层，而答案也只在最后一层，所以奇偶保存能够减少空间
				}
			}
		}
	}
	
	
	int ans = 0;
	
	// for(int i = 1; i <= n; i++){
		for(int j = 0; j < stats.size(); j++){
			for(int k = 0; k < stats.size(); k++){
				ans = max(ans, f[n & 1][stats[j]][stats[k]]);
			}
		}
	// }
	
	cout << ans << endl;
	
	return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/50828?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号