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

卡码网训练（ACM模式）-代码随想录

作者：小小林熬夜学编程 | 2024-04-13 23:20:31

赞

踩

卡码网

一.数组

卡码网33.逛街

思路一：

                1.先将输入字符转换为int数组
                2.使用栈从0遍历数组，保存第i位之前可以连续降序的数值
                3.使用栈从n-1遍历数组，保存第i位之后可以连续降序的数值
                4.及时更新第i个位置前后存在的到达i之前连续降序的数值个数
  1. #include <iostream>
  2. #include <vector>
  3. #include <sstream>
  4. #include <stack>
  5. #include <algorithm>
  6. using namespace std;
  7. vector<int> parseIntArray(string input) {//获取高度数组
  8.     vector<int> parsedArray;
  9.     stringstream ss(input.substr(1, input.length() - 2));//使用字符串流stringstream处理输入字符串，并把头尾的括号去掉
  10.     string item;
  11.     while (getline(ss, item, ',')) {//使用getline从stringstream中按逗号分割获取每个字符串元素
  12.         parsedArray.push_back(std::stoi(item));//将字符串元素转为数字
  13.     }
  14.     return parsedArray;
  15. }
  16.  
  17. void calculateVisibleCounts(const vector<int>& heights, vector<int>& visibleCounts) {
  18.     int n = heights.size();
  19.     stack<int> stack1, stack2;
  20.  
  21.     for (int i = 0; i < n; i++) {//从左往右找（相当于看第i位左边符合条件的）
  22.         visibleCounts[i] += stack1.size();//降序排列的数值，就是从当前位置起栈里的都能看到，当前位置的初始化已经加上
  23.         while (!stack1.empty() && stack1.top() <= heights[i]) {//第i位元素是否大于等于前面的元素时，把前面的元素弹出
  24.             stack1.pop();                                      //直到找到一个比当前元素大的值，或者栈空
  25.         }                                                      //使得栈中的元素全是按降序排列的（从底到顶）
  26.         stack1.push(heights[i]);//把当前位置加入
  27.     }
  28.  
  29.     for (int i = n - 1; i >= 0; i--) {//从右往左找（相当于看第i位右边符合条件的
  30.         visibleCounts[i] += stack2.size();//同理把从右往左能看到的都加上
  31.         while (!stack2.empty() && stack2.top() <= heights[i]) {//等于的时候也要弹出，因为等于也看不见
  32.             stack2.pop();//也是形成降序排列
  33.         }
  34.         stack2.push(heights[i]);
  35.     }
  36. }
  37.  
  38. int main() {
  39.     string buildings;
  40.     while(getline(cin, buildings)){
  41.         vector<int> heights = parseIntArray(buildings);
  42.         int n = heights.size();
  43.         vector<int> visibleCounts(n, 1);//初始化都为1，因为在第i个位置上，必然能看到第i个位置
  44.         calculateVisibleCounts(heights, visibleCounts);
  45.         cout << "[";
  46.         for (int i = 0; i < n; i++) {
  47.             cout << visibleCounts[i];
  48.             if (i < n - 1) 
  49.                 cout << ",";
  50.         }
  51.         cout << "]" <<endl;
  52.     }
  53.     
  54.     
  55.     
  56.     // 输出可见建筑物数量
  57.     
  58.  
  59.     return 0;
  60. }

卡码网13.镂空三角形

思路：根据题意，可以把结果分成四个部分
                1.打印空格（空格的数量是递减的，且最后一行不需要）
                2.打印字符（相当于左侧字符，前n-1行都只需打印一个，最后一行需打印n个）
                3.打印空格（属于中间空格，发现符合2*i-1的规律递增，最后一行无需打印）
                4.打印字符（相当于右侧字符，第一行无需打印，2到n-1行打印一个，最后一行打印n-1个
  1. #include<iostream>
  2. #include<sstream>
  3. using namespace std;
  4. int main() {
  5.     string str;
  6.     while (getline(cin, str)) {
  7.         stringstream ss(str);
  8.         char midC;
  9.         
  10.         int midI;
  11.         ss >> midC;
  12.         if (midC == '@')
  13.             break;
  14.         ss >> midI;
  15.         for (int i = 0; i < midI; i++) {
  16.             //打印空格
  17.             int midP = midI - i-1;
  18.             while (midP--)
  19.                 cout << ' ';
  20.             //打印字符
  21.             int midS = midI;
  22.             if (i != midI - 1)
  23.                 cout << midC;
  24.             else {
  25.                 while (midS--)
  26.                     cout << midC;
  27.             }
  28.             //打印空格
  29.             if (i != midI - 1 && i!=0) {
  30.                 int midC1 = 2 * i-1 ;
  31.                 while (midC1--)
  32.                     cout << ' ';
  33.             }
  34.             
  35.             //打印字符
  36.             if (i == 0) {
  37.                 cout << endl;
  38.                 continue;
  39.  
  40.             }
  41.                 
  42.             int midC2 = midI;
  43.             if (i != midI - 1)
  44.                 cout << midC;
  45.             else {
  46.                 midC2--;
  47.                 while (midC2--)
  48.                     cout << midC;
  49.             }
  50.             cout << endl;
  51.         }
  52.         cout << endl;
  53.     }
  54.     return 0;
  55. }

 二.字符串

卡码网14.句子缩写

思路一：直接使用字符串流接收数据，然后赋给string
注意：使用cin获取n之后需要使用getchar() 吸收一个回车，因为第一行只需要一个n
  1. #include<iostream>
  2. #include<sstream>
  3. using namespace std;
  4.  
  5. int main() {
  6.     int n;
  7.     cin>>n;
  8.     getchar();
  9.     string str;
  10.     while (n--) {
  11.         getline(cin, str);
  12.         string res;
  13.         stringstream ss(str);
  14.         string mid;
  15.         while (ss >> mid) {
  16.             //大写字母65-90 小写字母97-122
  17.             if (mid[0] - 'a' >= 0)//为小写字母
  18.                 res.push_back(mid[0] - 32);
  19.             else
  20.                 res.push_back(mid[0]);
  21.         }
  22.         cout << res << endl;
  23.     }
  24.     return 0;
  25. }

卡玛网15.神秘字符

思路：使用双指针把第一个字符的后半部分往后移，腾出第二个字符的位置
  1. #include<iostream>
  2. using namespace std;
  3. string displayString(string& first,string& second){
  4.     int lenF=first.size();
  5.     int lenS=second.size();
  6.     first.resize(lenF+lenS);
  7.     int left=lenF-1,right=lenF+lenS-1;//相当于把后一半的字符移动到后面，腾出second的位置
  8.     while(left>=(lenF/2)){
  9.         first[right--]=first[left--];
  10.     }
  11.     for(auto it:second){
  12.         first[++left]=it;
  13.     }
  14.     return first;
  15. }
  16. int main(){
  17.     int n;
  18.     cin>>n;
  19.     getchar();
  20.     while(n--){
  21.         string fisrt;
  22.         getline(cin,fisrt);
  23.         string second;
  24.         getline(cin,second);
  25.         cout<<displayString(fisrt,second)<<endl;
  26.     }
  27.     return 0;
  28. }

卡码网16.位置交换

思路：简单的奇偶交换，使用双指针指向，然后每次递增2
  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4.     int n;
  5.     cin>>n;
  6.     getchar();
  7.     while(n--){
  8.         string str;
  9.         getline(cin,str);
  10.         int i=0,j=1;
  11.         while(i<str.size()-1 && j<str.size()){
  12.             char temp=str[i];
  13.             str[i]=str[j];
  14.             str[j]=temp;
  15.             i+=2;
  16.             j+=2;
  17.         }
  18.         
  19.         cout<<str<<endl;
  20.         
  21.     }
  22.     
  23.     
  24.     return 0;
  25. }

三.栈和队列

卡码网17.出栈合法性

思路：
遍历每一个出栈的数字，遍历到i时，就判断栈中是否入栈到i。
1.还没有入栈到i，先入栈到i，此时出栈合法
2.已经入栈到i后面，判断栈顶元素是否等于出栈元素
  • 等于时出栈合法
  • 不等于时出栈不合法
  1. #include<iostream>
  2. #include<stack>
  3. #include<sstream>
  4. using namespace std;
  5.  
  6. int main() {
  7.     int n;
  8.     while (cin >> n) {
  9.         if (n == 0)
  10.             break;
  11.         getchar();//换到下一行
  12.         string str;
  13.         getline(cin, str);
  14.         stringstream ss(str);
  15.         int outNum, intNum = 1;//出栈和入栈下标
  16.         stack<int> st;
  17.         bool judge = true;//判断是否出栈成功
  18.         while (ss >> outNum) {
  19.             //cout << outNum << endl;
  20.             while (outNum >= intNum) {
  21.                 st.push(intNum++);
  22.             }
  23.             //出栈
  24.             //cout << st.top() << endl;
  25.             if (st.top() == outNum)//当前元素可以出栈成功
  26.                 st.pop();
  27.             else {//当前元素无法出栈
  28.                 judge = false;
  29.                 break;
  30.             }
  31.         }
  32.         if (!judge)
  33.             cout << "No" << endl;
  34.         else
  35.             cout << "Yes" << endl;
  36.     }
  37.     return 0;
  38. }

四.链表

卡码网18.链表的基本操作

问题：本地编译器和运行都没问题，但是提交之后（show和delete）会多出空格

  1. #include<iostream>
  2. #include<string>
  3. #include<sstream>
  4. #include<vector>
  5. #include<stack>
  6. using namespace std;
  7.  
  8. struct TreeNode {
  9.     int val;
  10.     TreeNode* next;
  11.     TreeNode() {
  12.         val = 0;
  13.         next = nullptr;
  14.     }
  15.     TreeNode(int _val) {
  16.         val = _val;
  17.         next = nullptr;
  18.     }
  19. };
  20. TreeNode* newRoot = new TreeNode();
  21. int List_size = 0;
  22. string get(TreeNode* root, int index) {//获取指定位置元素
  23.     if (index > List_size)
  24.         return "get fail";
  25.     TreeNode* cur = root;
  26.     while (--index) {
  27.         if (cur->next)
  28.             cur = cur->next;
  29.         else
  30.             return "get fail";
  31.     }
  32.     return to_string(cur->val);
  33. }
  34.  
  35. TreeNode* insert(TreeNode* root, int index, int val) {//在指定位置之前插入元素
  36.     if (index == 1) {
  37.         TreeNode* node = new TreeNode(val);
  38.         node->next = newRoot->next;
  39.         newRoot->next = node;
  40.         cout << "insert OK";
  41.         List_size++;
  42.         return node;
  43.     }
  44.     if (index <= 0 || index > List_size) {
  45.         cout << "insert fail";
  46.         return root;
  47.     }
  48.     TreeNode* node = new TreeNode(val);
  49.     TreeNode* pre = newRoot, * cur = root;
  50.     while (--index) {
  51.         if (cur->next) {
  52.             pre = cur;
  53.             cur = cur->next;
  54.         }
  55.         else {
  56.             cout << "insert fail";
  57.             return root;
  58.         }
  59.     }
  60.     node->next = pre->next;
  61.     pre->next = node;
  62.     cout << "insert OK";
  63.     List_size++;
  64.     return newRoot->next;
  65. }
  66. TreeNode* deleteNode(TreeNode* root, int index) {//删除指定位置的元素
  67.     if (index <= 0 || index > List_size) {
  68.         cout << "delete fail";
  69.         return root;
  70.     }
  71.     TreeNode* pre = newRoot, * cur = root;
  72.     while (--index) {
  73.         if (cur->next) {
  74.             pre = cur;
  75.             cur = cur->next;
  76.         }
  77.         else {
  78.             cout << "delete fail";
  79.             return root;
  80.         }
  81.     }
  82.     if (cur->next)
  83.         pre->next = cur->next;
  84.     else
  85.         pre->next = nullptr;
  86.     cur = nullptr;
  87.     cout << "delete OK";
  88.     List_size--;
  89.     return newRoot->next;
  90. }
  91. void showNodes(TreeNode* root) {//打印链表中所有元素
  92.     if (List_size == 0){
  93.         cout << "Link list is empty";
  94.         return;
  95.     }
  96.         
  97.     TreeNode* cur = root;
  98.     while (cur) {
  99.         cout << cur->val;
  100.         if (cur->next)
  101.             cout << " ";
  102.         cur = cur->next;
  103.     }
  104. }
  105. int main() {
  106.     TreeNode* cur = newRoot;
  107.     int n, midNum;
  108.     cin >> n;
  109.     stack<int>st;
  110.     while (n--) {//初始化链表
  111.         cin >> midNum;
  112.         st.push(midNum);
  113.     }
  114.     List_size = st.size();
  115.     while (!st.empty()) {
  116.         TreeNode* node = new TreeNode(st.top());
  117.         st.pop();
  118.         cur->next = node;
  119.         cur = node;
  120.     }
  121.     getchar();//换行
  122.     cin >> n;
  123.     getchar();
  124.     int index, val;
  125.     while (n--) {
  126.         string mid;
  127.         cin >> mid;
  128.         
  129.         if (mid == "get")
  130.         {
  131.              cin >> index;
  132.              cout << get(newRoot->next, index);
  133.         }
  134.         else if (mid == "insert")
  135. 		{
  136.             cin >> index;
  137.             cin >> val;
  138.             newRoot->next = insert(newRoot->next, index, val);
  139.         }
  140.         else if (mid == "delete") {
  141.             cin >> index;
  142.             newRoot->next = deleteNode(newRoot->next, index);
  143.         }
  144.         else if (mid == "show") {
  145.             showNodes(newRoot->next);
  146.         }
  147.         cout << endl;
  148.      }
  149.     return 0;
  150. }

卡码网19.单链表反转

思路：创建，递归反转
  1. #include<iostream>
  2. using namespace std;
  3.  
  4. struct ListNode {
  5.     int val;
  6.     ListNode* next;
  7.     ListNode() {
  8.         val = 0;
  9.         next = nullptr;
  10.     }
  11.     ListNode(int _val) {
  12.         val = _val;
  13.         next = nullptr;
  14.     }
  15. };
  16. ListNode* newHead = new ListNode(1);
  17.  
  18. ListNode* judge(ListNode* root) {
  19.     if (root->next == nullptr) return root;
  20.     ListNode* newRoot = judge(root->next);
  21.     root->next->next = root;
  22.     root->next = nullptr;
  23.     return newRoot;
  24. }
  25. void display(ListNode* root) {
  26.     ListNode* cur = root;
  27.     while (cur) {
  28.         cout << cur->val;
  29.         if (cur->next)
  30.             cout << " ";
  31.         cur = cur->next;
  32.     }
  33. }
  34. int main() {
  35.     ListNode* cur = newHead;
  36.     int n;
  37.     while (cin >> n) {
  38.         if (n == 0) {
  39.             cout << "list is empty" << endl;
  40.             continue;
  41.         }
  42.         int midNum;
  43.         while (n--) {//构建链表
  44.             cin >> midNum;
  45.             //cout << midNum;
  46.             ListNode* node = new ListNode(midNum);
  47.             cur->next = node;
  48.             cur = node;
  49.         }
  50.         ListNode* head = newHead->next;
  51.         
  52.         ListNode* n1 = head;
  53.         newHead = nullptr;
  54.         delete newHead;
  55.         //display(head);
  56.         head=judge(head);
  57.         display(head);
  58.         cout << endl;
  59.     }
  60.  
  61.  
  62.     return 0;
  63. }

20.删除重复元素

 思路：双指针

  1. #include<iostream>
  2. using namespace std;
  3. struct ListNode {
  4.     int val;
  5.     ListNode* next;
  6.     ListNode() {
  7.         val = 0;
  8.         next = nullptr;
  9.     }
  10.     ListNode(int _val) {
  11.         val = _val;
  12.         next = nullptr;
  13.     }
  14. };
  15.  
  16. void display(ListNode* root) {
  17.     ListNode* cur = root;
  18.     while (cur) {
  19.         cout << cur->val;
  20.         if(cur->next)
  21.             cout<<" ";
  22.         cur = cur->next;
  23.     }
  24.     cout << endl;
  25. }
  26.  
  27. void deleteNode(ListNode* root) {
  28.     ListNode* p = root, * cur = root->next;
  29.     while (cur) {
  30.         if (p->val == cur->val) {
  31.             if (cur->next) {
  32.                 p->next = cur->next;
  33.                 cur = p->next;
  34.             }
  35.             else {
  36.                 p->next = nullptr;
  37.                 cur=nullptr;
  38.             }
  39.         }
  40.         else {
  41.             p = cur;
  42.             cur = cur->next;
  43.         }
  44.     }
  45. }
  46. int main() {
  47.     int n;
  48.     while (cin >> n) {
  49.         if (n == 0){
  50.             cout<<"list is empty";
  51.             break;
  52.         }
  53.         ListNode* head = new ListNode(0);
  54.         ListNode* pre = head;
  55.         int midNum;
  56.         while (n--) {//创建链表
  57.             cin >> midNum;
  58.             ListNode* node = new ListNode(midNum);
  59.             pre->next = node;
  60.             pre = node;
  61.         }
  62.         display(head->next);
  63.         deleteNode(head);
  64.         display(head->next);
  65.     }
  66.     return 0;
  67. }

五.二叉树 

卡码网21.构造二叉树

思路一：根据前序遍历找出中间节点，然后把两个字符串切割递归遍历
  1. #include<iostream>
  2. #include<sstream>
  3. using namespace std;
  4. struct TreeNode {
  5.     char val;
  6.     TreeNode* left;
  7.     TreeNode* right;
  8.     TreeNode() {
  9.         val = 0;
  10.         left = nullptr;
  11.         right = nullptr;
  12.     }
  13.     TreeNode(int _val) {
  14.         val = _val;
  15.         left = nullptr;
  16.         right = nullptr;
  17.     }
  18. };
  19.  
  20. TreeNode* buildTree(string& PreSort, string& MidSort) {
  21.     if (PreSort.size() == 0) return nullptr;
  22.     int midValue = PreSort[0];
  23.     TreeNode* midNode = new TreeNode(midValue);//中间节点
  24.     //找到中间节点下标
  25.     int midIndex = 0;
  26.     while (MidSort[midIndex] != midValue)
  27.         midIndex++;
  28.     //分割中序数组(左闭右开)
  29.     string leftMidSort(MidSort.begin(), MidSort.begin() + midIndex);
  30.     string rightMidSort(MidSort.begin() + midIndex + 1, MidSort.end());
  31.  
  32.     //分割前序数组（左闭右开）
  33.     string leftPreSort(PreSort.begin() + 1, PreSort.begin() + leftMidSort.size() + 1);
  34.     string rightPreSort(PreSort.begin() + leftMidSort.size() + 1, PreSort.end());
  35.  
  36.     midNode->left = buildTree(leftPreSort, leftMidSort);
  37.     midNode->right = buildTree(rightPreSort, rightMidSort);
  38.  
  39.     return midNode;
  40.  
  41. }
  42. void display(TreeNode* root) {
  43.     if (root == nullptr) return;
  44.     display(root->left);
  45.     display(root->right);
  46.     cout << root->val;
  47. }
  48. int main() {
  49.     string str;
  50.     while (getline(cin, str)) {
  51.         stringstream ss(str);
  52.         string PreSort, MidSort;
  53.         ss >> PreSort >> MidSort;
  54.         TreeNode* root = buildTree(PreSort, MidSort);
  55.         display(root);
  56.         cout << endl;
  57.     }
  58.     return 0;
  59. }

卡码网22.二叉树的遍历

思路：使用make_pair组合左右节点的下标对应的字符
  1. #include<iostream>
  2. #include<vector>
  3. #include<unordered_map>
  4. #include<sstream>
  5. using namespace std;
  6.  
  7. struct TreeNode{
  8.     char val;
  9.     TreeNode*left;
  10.     TreeNode*right;
  11.     TreeNode(char _val){
  12.         val=_val;
  13.         left=nullptr;
  14.         right=nullptr;
  15.     }
  16. };
  17. //节点连接
  18. TreeNode* connectTree(unordered_map<char, pair<char, char>>& nodeMap, char rootValue){
  19.      if (rootValue == '0') {
  20.         return nullptr;
  21.     }
  22.  
  23.     TreeNode* root = new TreeNode(rootValue);
  24.     int leftChild = nodeMap[rootValue].first;
  25.     int rightChild = nodeMap[rootValue].second;
  26.  
  27.     root->left = connectTree(nodeMap, leftChild);
  28.     root->right =connectTree(nodeMap, rightChild);
  29.  
  30.     return root;
  31. }
  32. //遍历
  33. void predisplay(TreeNode*root){
  34.     if(root==nullptr) return;
  35.     cout<<root->val;
  36.     predisplay(root->left);
  37.     predisplay(root->right);
  38. }
  39. void middisplay(TreeNode*root){
  40.     if(root==nullptr) return;
  41.     middisplay(root->left);
  42.     cout<<root->val;
  43.     middisplay(root->right);
  44. }
  45. void lastdisplay(TreeNode*root){
  46.     if(root==nullptr) return;
  47.     lastdisplay(root->left);
  48.     lastdisplay(root->right);
  49.     cout<<root->val;
  50. }
  51. int main(){
  52.     int n;
  53.     cin >> n;
  54.     unordered_map<char, pair<char, char>> nodeMap;
  55.  
  56.     // 先保存输入的数据 
  57.     vector<char> index = vector<char>(n + 1, '0'); //保存坐标
  58.     vector<vector<int>> nums = vector<vector<int>>(n + 1, vector<int>(2, 0));
  59.     for (int i = 1; i <= n; i++) {
  60.         cin >> index[i] >> nums[i][0] >> nums[i][1];
  61.     }
  62.  
  63.     // 生成二叉树 
  64.     for (int i = 1; i <= n; i++) {
  65.         nodeMap[index[i]] = make_pair(index[nums[i][0]], index[nums[i][1]]);
  66.     }
  67.     TreeNode*root=connectTree(nodeMap, index[1]);
  68.     predisplay(root);
  69.     cout<<endl;
  70.     middisplay(root);
  71.     cout<<endl;
  72.     lastdisplay(root);
  73.     cout<<endl;
  74.     return 0;
  75. }

卡码网23.二叉树的高度

思路一：截取区间创建二叉树，遍历二叉树获取高度
  1. #include<iostream>
  2. using namespace std;
  3.  
  4. struct TreeNode {
  5.     char val;
  6.     TreeNode* left;
  7.     TreeNode* right;
  8.     TreeNode() :val(0), left(nullptr), right(nullptr) {};
  9.     TreeNode(int _val) :val(_val), left(nullptr), right(nullptr) {};
  10. };
  11. TreeNode* buildTree(string& strPre, string& strMid) {
  12.     if (strPre.size() == 0) return nullptr;
  13.  
  14.     int midValue = strPre[0];
  15.  
  16.     int midIndex = 0;//获取中间节点的下标
  17.     while (strMid[midIndex] != midValue)
  18.         midIndex++;
  19.     //创建中间节点
  20.     TreeNode* root = new TreeNode(midValue);
  21.     if (strPre.size() == 1) return root;
  22.  
  23.     //分割中序
  24.     string leftMid(strMid.begin(), strMid.begin() + midIndex);
  25.     string rightMid(strMid.begin() + midIndex+1, strMid.end());
  26.     strPre.erase(strPre.begin());
  27.     //分割前序
  28.     string leftPre(strPre.begin(), strPre.begin() + leftMid.size());
  29.     string rightPre(strPre.begin() + leftMid.size(), strPre.end());
  30.  
  31.     root->left = buildTree(leftPre, leftMid);
  32.     root->right = buildTree(rightPre, rightMid);
  33.  
  34.     return root;
  35. }
  36. int heightMax = 0;
  37. void sumheight(TreeNode* root, int height) {
  38.     if (root == nullptr) return;
  39.     heightMax = max(height, heightMax);
  40.     sumheight(root->left, height + 1);
  41.     sumheight(root->right, height + 1);
  42. }
  43. int main() {
  44.     int n;
  45.     while (cin >> n) {
  46.         int midn = n;
  47.         string strPre, strMid;
  48.         char mid;
  49.         while (n--) {
  50.             cin >> mid;
  51.             strPre.push_back(mid);
  52.         }
  53.         while (midn--) {
  54.             cin >> mid;
  55.             strMid.push_back(mid);
  56.         }
  57.         TreeNode* root = buildTree(strPre, strMid);
  58.         sumheight(root, 1);
  59.         cout << heightMax << endl;
  60.  
  61.     }
  62.  
  63.  
  64.  
  65.  
  66.     return 0;
  67. }

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号