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

五子棋简易AI算法_五子棋ai

作者：羊村懒王 | 2024-04-02 20:30:25

赞

踩

五子棋ai

一、基本思想：五子棋存在多种连接方式，这也就决定了每一个空位的权值有所不同，我们对五子棋的不同连接方式设置权值，然后遍历棋盘，算出每一个空位上的权值，选择权值最大的空位下棋，所以这个算法的关键就在于：1.设置并且存储不同连接方式及其对应的权值 2.计算棋盘空位上的权值。

二、设置不同连接方式的权值并进行存储

棋子的连接分为活连与死连，假设0代表空位，1代表黑棋，2代表白旗，如010为活连，01（遇到边界）为死连为不同连接方式设置对应权值：

假设0代表空位，1代表黑棋，2代表白旗

权值表（还可以细分）

连接方式 权值 010 50 0110 150 01110 500 011110 3000 020 50 0220 150 02220 500 022220 3000 01 30 011 90 0111 300 01111 3000 02 30 022 90 0222 300 02222 3000

 

设置好权值表后，就要考虑如何存储权值表，因为权值表中的数据是用来后续计算空位总权值所需的。这里我们考虑用哈希表进行存储“连接方式——权值”这样子的键值对

Key-Value ： 键值对 

HashMap：

  • 将键值对一起存入 ，可以通过键来查询对应的值

  • 将连子情况作为Key ，权值分作为Value

  • 1: 键不能重复，值可以重复

  • 2： HashMap 存储优势是 查询时是O1的时间复杂度

  • 3： HashMap 存储原理：

    • 1： 用key来计算一个hash值 (当作唯一标识)，hash值然后作为下标 ，然后将k-v存储在数组中对应下标位置

  • 操作：

    • 实例化： HashMap<String,Integer> codeMap = new HashMap();
    • 方法： code.put(key,value);/ value = code.get(key);
  1.  static HashMap<String, Integer> codeMap = new HashMap<> ();
  2.     static int[][] codeArrray = new int[16][16];    //创建用来存储权值的二维数组
  3.  
  4.     // 静态代码块
  5.     static{
  6.         codeMap.put ("010", 50);
  7.         codeMap.put ("0110", 150);
  8.         codeMap.put ("01110", 500);
  9.         codeMap.put ("011110", 3000);
  10.  
  11.         codeMap.put ("020", 50);
  12.         codeMap.put ("0220", 150);
  13.         codeMap.put ("02220", 500);
  14.         codeMap.put ("022220", 3000);
  15.  
  16.         codeMap.put ("01", 30);
  17.         codeMap.put ("011", 90);
  18.         codeMap.put ("0111", 300);
  19.         codeMap.put ("01111", 3000);
  20.  
  21.         codeMap.put ("02", 30);
  22.         codeMap.put ("022", 90);
  23.         codeMap.put ("0222", 300);
  24.         codeMap.put ("02222", 3000);
  25.  
  26.         Integer integer = codeMap.get ("010");
  27.         System.out.println (integer);
  28.     }

三、遍历表格计算权值

如图一个五子棋盘：

 

尝试计算a、b两个空位处的权值大小，我们可以发现空位处的连接可以往上、下、左、右、左上、右上、左下、右下一共8个方向进行搜索，同时我们再规定一个空位的权值由八个方向的连接带来的权值简单相加得到（规则不唯一）。

对于a，往左的连接为01，权值30；往下的连接为01，权值30；往右下的连接010，权值50，故a处的权值为30+30+50=110

对于b，往左的连接为022，权值90；往上的连接为01，权值30；往左上的连接为011，权值90，故b处的权值为90+30+90=210

有了上面的举例，下面通过遍历计算每一个空位的权值

  1.     private static void getCodeArray(int[][] arr){
  2.  
  3.         for(int i = 0; i < arr.length; i++){
  4.             for(int j = 0; j < arr[i].length; j++){
  5.                 int chessNum = arr[i][j];
  6.                 // 遍历所有的空格
  7.                 if(chessNum == 0){
  8.                     toRight (i, j, arr);    //往右走的权值
  9.                     toLeft(i,j,arr);
  10.                     toUp(i,j,arr);
  11.                     toDown(i,j,arr);
  12.                     toLeftUp(i,j,arr);  //往左上走的权值
  13.                     toRightup(i,j,arr);
  14.                     toLeftDown(i,j,arr);
  15.                     toRightDown(i,j,arr);
  16.                 }
  17.             }
  18.         }
  19.  
  20.     }

上面的代码中往8个方向计算权值，但是方法还未定义，下面以往右和往左上为例

往右：

  1.     private static void toRight(int i, int j, int[][] chessArray){
  2.         // 等于0
  3.         int chessNum = chessArray[i][j];
  4.         // 右边是0/墙 return
  5.         if(j + 1 >= chessArray[i].length || chessArray[i][j + 1] == 0){
  6.             return;
  7.         }
  8.         // 右边第一个颗是1/2 记录下来
  9.         int chessNumR1 = chessArray[i][j + 1];
  10.         String codeStr = "" + chessNum + chessNumR1;
  11.         // 右边第二颗 0/与第一颗相同的/不同的/墙
  12.         for(int m = j + 2; m < chessArray[i].length; m++){
  13.             int chessNumRn = chessArray[i][m];
  14.             if(chessNumRn != 0){
  15.                 if(chessNumR1 == chessNumRn){
  16.                     // 找到相同的就拼接一个棋子标识
  17.                     codeStr += chessNumR1;
  18.                 } else if(chessNumR1 != chessNumRn){
  19.                     // 找到不相同的就结束循环
  20.                     break;
  21.                 }
  22.             } else{
  23.                 // 活连的结尾 就结束循环
  24.                 codeStr += "0";
  25.                 break;
  26.             }
  27.  
  28.         }
  29.         Integer codeValue = codeMap.get (codeStr);
  30.         if(codeValue == null){
  31.             return;
  32.         }
  33.         // 将权值分存入 一个 新的权值二维数组
  34.         codeArrray[i][j] += codeValue;
  35.  
  36.     }

往左上：

  1.  private static void toLeftUp(int i, int j, int[][] chessArray) {
  2.         // 等于0
  3.         int chessNum = chessArray[i][j];
  4.         // 左上边是0/墙 return
  5.         if(i - 1 <= -1||j - 1<= -1|| chessArray[i - 1][j - 1] == 0){
  6.             return;
  7.         }
  8.         // 左上边第一个颗是1/2 记录下来
  9.         int chessNumR1 = chessArray[i - 1][j - 1];
  10.         String codeStr = "" + chessNum + chessNumR1;
  11.         // 左上边第二颗 0/与第一颗相同的/不同的/墙
  12.         for(int k = i - 2; k > -1; k--) {
  13.             for (int m = j - 2; m > -1; m--) {
  14.                 int chessNumRn = chessArray[k][m];
  15.                 if (chessNumRn != 0) {
  16.                     if (chessNumR1 == chessNumRn) {
  17.                         // 找到相同的就拼接一个棋子标识
  18.                         codeStr += chessNumR1;
  19.                     } else if (chessNumR1 != chessNumRn) {
  20.                         // 找到不相同的就结束循环
  21.                         break;
  22.                     }
  23.                 } else {
  24.                     // 活连的结尾 就结束循环
  25.                     codeStr += "0";
  26.                     break;
  27.                 }
  28.  
  29.             }
  30.         }
  31.         Integer codeValue = codeMap.get (codeStr);
  32.         if(codeValue == null){
  33.             return;
  34.         }
  35.         // 将权值分存入 一个 新的权值二维数组
  36.         codeArrray[i][j] += codeValue;
  37.     }

这里无论是往哪个方向，计算出来的权值都需要累加到codeArray对应位置，codeArray是已经定义的存储权值的二维数组

完整代码：

  1. package com.zsj0929;
  2. import java.util.HashMap;
  3.  
  4. public class AI {// 会在类使用的时候初始化
  5.     static HashMap<String, Integer> codeMap = new HashMap<> ();
  6.     static int[][] codeArrray = new int[16][16];
  7.  
  8.     // 静态代码块
  9.     static{
  10.         codeMap.put ("010", 50);
  11.         codeMap.put ("0110", 150);
  12.         codeMap.put ("01110", 500);
  13.         codeMap.put ("011110", 3000);
  14.  
  15.         codeMap.put ("020", 50);
  16.         codeMap.put ("0220", 150);
  17.         codeMap.put ("02220", 500);
  18.         codeMap.put ("022220", 3000);
  19.  
  20.         codeMap.put ("01", 30);
  21.         codeMap.put ("011", 90);
  22.         codeMap.put ("0111", 300);
  23.         codeMap.put ("01111", 3000);
  24.  
  25.         codeMap.put ("02", 30);
  26.         codeMap.put ("022", 90);
  27.         codeMap.put ("0222", 300);
  28.         codeMap.put ("02222", 3000);
  29.  
  30.         Integer integer = codeMap.get ("010");
  31.         System.out.println (integer);
  32.     }
  33.  
  34.     public static void main(String[] args){
  35.         int[][] arr = {
  36.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  37.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  38.                 {0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  39.                 {0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  40.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  41.                 {0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  42.                 {0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  43.                 {0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  44.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  45.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  46.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  47.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  48.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  49.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  50.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  51.                 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
  52.         };
  53.         // 遍历计算所有可以下棋的地方的权值
  54.         getCodeArray (arr);
  55.         // 获取矩阵中权值最大的位置
  56.  
  57.         for(int i = 0; i < codeArrray.length; i++){
  58.             for(int j = 0; j < codeArrray[i].length; j++){
  59.                 System.out.print (codeArrray[i][j] + "     ");
  60.             }
  61.             System.out.println ();
  62.         }
  63.     }
  64.  
  65.     private static void getCodeArray(int[][] arr){
  66.  
  67.         for(int i = 0; i < arr.length; i++){
  68.             for(int j = 0; j < arr[i].length; j++){
  69.                 int chessNum = arr[i][j];
  70.                 // 遍历所有的空格
  71.                 if(chessNum == 0){
  72.                     toRight (i, j, arr);    //往右走的权值
  73.                     toLeft(i,j,arr);
  74.                     toUp(i,j,arr);
  75.                     toDown(i,j,arr);
  76.                     toLeftUp(i,j,arr);  //往左上走的权值
  77.                     toRightup(i,j,arr);
  78.                     toLeftDown(i,j,arr);
  79.                     toRightDown(i,j,arr);
  80.                 }
  81.             }
  82.         }
  83.  
  84.     }
  85.  
  86.     private static void toRightDown(int i, int j, int[][] chessArray) {
  87.         // 等于0
  88.         int chessNum = chessArray[i][j];
  89.         // 右下边是0/墙 return
  90.         if(i + 1 >= chessArray.length||j + 1>=chessArray.length || chessArray[i + 1][j + 1] == 0){
  91.             return;
  92.         }
  93.         // 右下边第一个颗是1/2 记录下来
  94.         int chessNumR1 = chessArray[i + 1][j + 1];
  95.         String codeStr = "" + chessNum + chessNumR1;
  96.         // 右下边第二颗 0/与第一颗相同的/不同的/墙
  97.         for(int k = i + 2; k < chessArray.length; k++) {
  98.             for (int m = j + 2; m < chessArray[i].length; m++) {
  99.                 int chessNumRn = chessArray[k][m];
  100.                 if (chessNumRn != 0) {
  101.                     if (chessNumR1 == chessNumRn) {
  102.                         // 找到相同的就拼接一个棋子标识
  103.                         codeStr += chessNumR1;
  104.                     } else if (chessNumR1 != chessNumRn) {
  105.                         // 找到不相同的就结束循环
  106.                         break;
  107.                     }
  108.                 } else {
  109.                     // 活连的结尾 就结束循环
  110.                     codeStr += "0";
  111.                     break;
  112.                 }
  113.  
  114.             }
  115.         }
  116.         Integer codeValue = codeMap.get (codeStr);
  117.         if(codeValue == null){
  118.             return;
  119.         }
  120.         // 将权值分存入 一个 新的权值二维数组
  121.         codeArrray[i][j] += codeValue;
  122.     }
  123.  
  124.     private static void toLeftDown(int i, int j, int[][] chessArray) {
  125.         // 等于0
  126.         int chessNum = chessArray[i][j];
  127.         // 左下边是0/墙 return
  128.         if(i + 1 >= chessArray.length||j - 1 <= -1 || chessArray[i + 1][j - 1] == 0){
  129.             return;
  130.         }
  131.         // 左下边第一个颗是1/2 记录下来
  132.         int chessNumR1 = chessArray[i + 1][j - 1];
  133.         String codeStr = "" + chessNum + chessNumR1;
  134.         // 左下边第二颗 0/与第一颗相同的/不同的/墙
  135.         for(int k = i + 2; k < chessArray.length; k++) {
  136.             for (int m = j - 2; m >= -1; m--) {
  137.                 int chessNumRn = chessArray[k][m];
  138.                 if (chessNumRn != 0) {
  139.                     if (chessNumR1 == chessNumRn) {
  140.                         // 找到相同的就拼接一个棋子标识
  141.                         codeStr += chessNumR1;
  142.                     } else if (chessNumR1 != chessNumRn) {
  143.                         // 找到不相同的就结束循环
  144.                         break;
  145.                     }
  146.                 } else {
  147.                     // 活连的结尾 就结束循环
  148.                     codeStr += "0";
  149.                     break;
  150.                 }
  151.  
  152.             }
  153.         }
  154.         Integer codeValue = codeMap.get (codeStr);
  155.         if(codeValue == null){
  156.             return;
  157.         }
  158.         // 将权值分存入 一个 新的权值二维数组
  159.         codeArrray[i][j] += codeValue;
  160.     }
  161.  
  162.     private static void toRightup(int i, int j, int[][] chessArray) {
  163.         // 等于0
  164.         int chessNum = chessArray[i][j];
  165.         // 右上边是0/墙 return
  166.         if(i - 1 <= -1||j + 1>=chessArray.length || chessArray[i - 1][j + 1] == 0){
  167.             return;
  168.         }
  169.         // 右上边第一个颗是1/2 记录下来
  170.         int chessNumR1 = chessArray[i - 1][j + 1];
  171.         String codeStr = "" + chessNum + chessNumR1;
  172.         // 右上边第二颗 0/与第一颗相同的/不同的/墙
  173.         for(int k = i - 2; k > -1; k--) {
  174.             for (int m = j + 2; m < chessArray[i].length; m++) {
  175.                 int chessNumRn = chessArray[k][m];
  176.                 if (chessNumRn != 0) {
  177.                     if (chessNumR1 == chessNumRn) {
  178.                         // 找到相同的就拼接一个棋子标识
  179.                         codeStr += chessNumR1;
  180.                     } else if (chessNumR1 != chessNumRn) {
  181.                         // 找到不相同的就结束循环
  182.                         break;
  183.                     }
  184.                 } else {
  185.                     // 活连的结尾 就结束循环
  186.                     codeStr += "0";
  187.                     break;
  188.                 }
  189.  
  190.             }
  191.         }
  192.         Integer codeValue = codeMap.get (codeStr);
  193.         if(codeValue == null){
  194.             return;
  195.         }
  196.         // 将权值分存入 一个 新的权值二维数组
  197.         codeArrray[i][j] += codeValue;
  198.     }
  199.  
  200.     private static void toLeftUp(int i, int j, int[][] chessArray) {
  201.         // 等于0
  202.         int chessNum = chessArray[i][j];
  203.         // 左上边是0/墙 return
  204.         if(i - 1 <= -1||j - 1<= -1|| chessArray[i - 1][j - 1] == 0){
  205.             return;
  206.         }
  207.         // 左上边第一个颗是1/2 记录下来
  208.         int chessNumR1 = chessArray[i - 1][j - 1];
  209.         String codeStr = "" + chessNum + chessNumR1;
  210.         // 左上边第二颗 0/与第一颗相同的/不同的/墙
  211.         for(int k = i - 2; k > -1; k--) {
  212.             for (int m = j - 2; m > -1; m--) {
  213.                 int chessNumRn = chessArray[k][m];
  214.                 if (chessNumRn != 0) {
  215.                     if (chessNumR1 == chessNumRn) {
  216.                         // 找到相同的就拼接一个棋子标识
  217.                         codeStr += chessNumR1;
  218.                     } else if (chessNumR1 != chessNumRn) {
  219.                         // 找到不相同的就结束循环
  220.                         break;
  221.                     }
  222.                 } else {
  223.                     // 活连的结尾 就结束循环
  224.                     codeStr += "0";
  225.                     break;
  226.                 }
  227.  
  228.             }
  229.         }
  230.         Integer codeValue = codeMap.get (codeStr);
  231.         if(codeValue == null){
  232.             return;
  233.         }
  234.         // 将权值分存入 一个 新的权值二维数组
  235.         codeArrray[i][j] += codeValue;
  236.     }
  237.  
  238.     private static void toDown(int i, int j, int[][] chessArray) {
  239.         // 等于0
  240.         int chessNum = chessArray[i][j];
  241.         // 下边是0/墙 return
  242.         if(i + 1 >= chessArray.length || chessArray[i + 1][j] == 0){
  243.             return;
  244.         }
  245.         // 下边第一个颗是1/2 记录下来
  246.         int chessNumR1 = chessArray[i + 1][j];
  247.         String codeStr = "" + chessNum + chessNumR1;
  248.         // 下边第二颗 0/与第一颗相同的/不同的/墙
  249.         for(int k = i + 2; k < chessArray.length; k++){
  250.             int chessNumRn = chessArray[k][j];
  251.             if(chessNumRn != 0){
  252.                 if(chessNumR1 == chessNumRn){
  253.                     // 找到相同的就拼接一个棋子标识
  254.                     codeStr += chessNumR1;
  255.                 } else if(chessNumR1 != chessNumRn){
  256.                     // 找到不相同的就结束循环
  257.                     break;
  258.                 }
  259.             } else{
  260.                 // 活连的结尾 就结束循环
  261.                 codeStr += "0";
  262.                 break;
  263.             }
  264.  
  265.         }
  266.         Integer codeValue = codeMap.get (codeStr);
  267.         if(codeValue == null){
  268.             return;
  269.         }
  270.         // 将权值分存入 一个 新的权值二维数组
  271.         codeArrray[i][j] += codeValue;
  272.  
  273.     }
  274.  
  275.     private static void toUp(int i, int j, int[][] chessArray) {
  276.         // 等于0
  277.         int chessNum = chessArray[i][j];
  278.         // 上边是0/墙 return
  279.         if(i - 1 <= -1 || chessArray[i - 1][j] == 0){
  280.             return;
  281.         }
  282.         // 上边第一个颗是1/2 记录下来
  283.         int chessNumR1 = chessArray[i - 1][j];
  284.         String codeStr = "" + chessNum + chessNumR1;
  285.         // 上边第二颗 0/与第一颗相同的/不同的/墙
  286.         for(int k = i - 2; k > -1; k--){
  287.             int chessNumRn = chessArray[k][j];
  288.             if(chessNumRn != 0){
  289.                 if(chessNumR1 == chessNumRn){
  290.                     // 找到相同的就拼接一个棋子标识
  291.                     codeStr += chessNumR1;
  292.                 } else if(chessNumR1 != chessNumRn){
  293.                     // 找到不相同的就结束循环
  294.                     break;
  295.                 }
  296.             } else{
  297.                 // 活连的结尾 就结束循环
  298.                 codeStr += "0";
  299.                 break;
  300.             }
  301.  
  302.         }
  303.         Integer codeValue = codeMap.get (codeStr);
  304.         if(codeValue == null){
  305.             return;
  306.         }
  307.         // 将权值分存入 一个 新的权值二维数组
  308.         codeArrray[i][j] += codeValue;
  309.     }
  310.  
  311.     private static void toLeft(int i, int j, int[][] chessArray) {
  312.         // 等于0
  313.         int chessNum = chessArray[i][j];
  314.         // 左边是0/墙 return
  315.         if(j - 1 <= -1 || chessArray[i][j - 1] == 0){
  316.             return;
  317.         }
  318.         // 左边第一个颗是1/2 记录下来
  319.         int chessNumR1 = chessArray[i][j - 1];
  320.         String codeStr = "" + chessNum + chessNumR1;
  321.         // 左边第二颗 0/与第一颗相同的/不同的/墙
  322.         for(int m = j - 2; m > -1; m--){
  323.             int chessNumRn = chessArray[i][m];
  324.             if(chessNumRn != 0){
  325.                 if(chessNumR1 == chessNumRn){
  326.                     // 找到相同的就拼接一个棋子标识
  327.                     codeStr += chessNumR1;
  328.                 } else if(chessNumR1 != chessNumRn){
  329.                     // 找到不相同的就结束循环
  330.                     break;
  331.                 }
  332.             } else{
  333.                 // 活连的结尾 就结束循环
  334.                 codeStr += "0";
  335.                 break;
  336.             }
  337.  
  338.         }
  339.         Integer codeValue = codeMap.get (codeStr);
  340.         if(codeValue == null){
  341.             return;
  342.         }
  343.         // 将权值分存入 一个 新的权值二维数组
  344.         codeArrray[i][j] += codeValue;
  345.     }
  346.  
  347.     private static void toRight(int i, int j, int[][] chessArray){
  348.         // 等于0
  349.         int chessNum = chessArray[i][j];
  350.         // 右边是0/墙 return
  351.         if(j + 1 >= chessArray[i].length || chessArray[i][j + 1] == 0){
  352.             return;
  353.         }
  354.         // 右边第一个颗是1/2 记录下来
  355.         int chessNumR1 = chessArray[i][j + 1];
  356.         String codeStr = "" + chessNum + chessNumR1;
  357.         // 右边第二颗 0/与第一颗相同的/不同的/墙
  358.         for(int m = j + 2; m < chessArray[i].length; m++){
  359.             int chessNumRn = chessArray[i][m];
  360.             if(chessNumRn != 0){
  361.                 if(chessNumR1 == chessNumRn){
  362.                     // 找到相同的就拼接一个棋子标识
  363.                     codeStr += chessNumR1;
  364.                 } else if(chessNumR1 != chessNumRn){
  365.                     // 找到不相同的就结束循环
  366.                     break;
  367.                 }
  368.             } else{
  369.                 // 活连的结尾 就结束循环
  370.                 codeStr += "0";
  371.                 break;
  372.             }
  373.  
  374.         }
  375.         Integer codeValue = codeMap.get (codeStr);
  376.         if(codeValue == null){
  377.             return;
  378.         }
  379.         // 将权值分存入 一个 新的权值二维数组
  380.         codeArrray[i][j] += codeValue;
  381.  
  382.     }
  383.  
  384. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/353721
推荐阅读
相关标签

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

  

闽ICP备14008679号