目录

1.图的输入：（处理）n行包含m个字符的字符串

2.（处理）一行用特殊字符分隔的字符串

1.图的输入：（处理）n行包含m个字符的字符串

例如：

5 5
..S..
****.
T....
****.
.....

/*题目描述
Jungle 生活在美丽的蓝鲸城，大马路都是方方正正，但是每天马路的封闭情况都不一样。地图由以下元素组成:
1)”.” - 空地，可以达到;
2)”*” - 路障，不可达到;
3)"S” - Jungle的家;
4)”T” - 公司.
其中我们会限制Jungle拐弯的次数，同时Jungle可以清除给定个数的路障，现在你的任务是计算Jungle是否可以从家里出发到达公司。

输入描述
输入的第一行为两个整数tc(o<tc<100)t代表可以拐弯的次数，c代表可以清除的路陪个数
输入的第二行为两个整数n,m(1≤n,m≤100),代表地图的大小。
接下来是n行包含m个字符的地图。n和m可能不一样大。
我们保证地图里有S和T。
输出描述
输出是否可以从家里出发到达公司，是则输出YES，不能则输出NO。

示例1：
输入
2 0
5 5
..S..
****.
T....
****.
.....
输出
YES

示例2：
输入
1 2
5 5
.*S*.
*****
..*..
*****
T....
输出
NO

说明 该用例中，至少需要拐弯1次，清除3个路障，所以无法到达*/
//用tuple和哈希
#include <iostream>
#include <vector>
#include <queue>
#include <string>
#include <unordered_set>
#include <functional>
#include <tuple>
using namespace std;

int main() {
    int tc, c;
    cin >> tc >> c;

    int n, m;
    cin >> n >> m;

    vector<string> grid(n);
    int start_x = -1, start_y = -1;
    int target_x = -1, target_y = -1;

    for (int i = 0; i < n; i++) {
        cin >> grid[i];
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 'S') {
                start_x = i;
                start_y = j;
            } else if (grid[i][j] == 'T') {
                target_x = i;
                target_y = j;
            }
        }
    }

    // 方向数组
    int dx[4] = {-1, 0, 1, 0};
    int dy[4] = {0, 1, 0, -1};

    // 使用unordered_set记录访问状态 (x, y, turns, clears, dir)
    unordered_set<string> visited;

    queue<tuple<int, int, int, int, int>> q; // x, y, turns, clears, dir

    // 从起点开始
    for (int dir = 0; dir < 4; dir++) {
        auto state = make_tuple(start_x, start_y, 0, 0, dir);
        string key = to_string(start_x) + "," + to_string(start_y) + "," +
                     to_string(0) + "," + to_string(0) + "," + to_string(dir);
        visited.insert(key);
        q.push(state);
    }

    bool found = false;

    while (!q.empty()) {
        auto [x, y, turns, clears, dir] = q.front();
        q.pop();

        if (x == target_x && y == target_y) {
            found = true;
            break;
        }

        for (int new_dir = 0; new_dir < 4; new_dir++) {
            int nx = x + dx[new_dir];
            int ny = y + dy[new_dir];

            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;

            int new_turns = turns;
            if (new_dir != dir) new_turns++;

            int new_clears = clears;
            if (grid[nx][ny] == '*') new_clears++;

            if (new_turns > tc || new_clears > c) continue;

            string new_key = to_string(nx) + "," + to_string(ny) + "," +
                           to_string(new_turns) + "," + to_string(new_clears) + "," +
                           to_string(new_dir);//状态编码为字符串

            if (visited.find(new_key) == visited.end()) {
                visited.insert(new_key);// 新状态，加入哈希表和队列
                q.push(make_tuple(nx, ny, new_turns, new_clears, new_dir));
            }
        }
    }

    cout << (found ? "YES" : "NO") << endl;

    return 0;
}

2.（处理）一行用特殊字符分隔的字符串

例如：

25G3C-abc-d（字符）

1,0,0,0,0,1,0,0,1,0,1（数字）

/*给定一个非空字符串 S，其被 N 个’-‘分隔成 N+1 的子串，给定正整数 K，要求除第一个子串外，其余的串每 K 个用’-‘分隔，并将小写字母转换为大写。

输入描述
正整数 K 和‘-’分割的字符串，如：
2
25G3C-abc-d
输出描述
转换后的字符串

示例 1 输入输出示例仅供调试，后台判题数据一般不包含示例
输入
4
5F3Z-2e-9-w
输出
5F3Z-2E9W
解释
字符串 S 被分成了两个部分，每部分 4 个字符；
注意，两个额外的破折号需要删掉。

示例 2 输入输出示例仅供调试，后台判题数据一般不包含示例
输入
2
2-5g-3-J
输出
2-5G-3J
解释
字符串 S 被分成了 3 个部分，按照前面的规则描述，第一部分的字符可以少于给定的数量，其余部分皆为 2 个字符。
*/
#include <iostream>
#include <cctype>
#include <string>
#include <algorithm>
using namespace std;
string f(int k,const string& s){
if(s.empty()){return "";}
 // 1. 先移除所有'-'并转换为大写
string cleanstr;
for(char c:s){
    if(c!='-'){
        cleanstr+=toupper(c);
    }
}
// 2. 找到第一个子串的结束位置（第一个'-'在原始字符串中的位置）
size_t firstend=0;
for(;firstend<s.size();firstend++){
    if(s[firstend]=='-')break;
}
int firstlen=firstend;
if(firstlen==s.size()){
    return cleanstr;
}
string result=cleanstr.substr(0,firstlen);

int remainlen=cleanstr.size()-firstlen;
for(int i=firstlen;i<cleanstr.size();i+=k){
    result+='-';
    int chunksize=min(k,remainlen);
    result+=cleanstr.substr(i,chunksize);

    remainlen-=chunksize;
}
return result;
}
int main(){
int k;string s;
cin>>k;
cin>>s;
string result=f(k,s);
cout<<result<<endl;
}

/*停车场有一横排车位，0代表没有停车，1代表有车。至少停了一辆车在车位上，也至少有一个空位没有停车为了防剐蹭，
需为停车人找到一个车位，使得距停车人的车最近的车辆的距离是最大的，返回此时的最大距离。

输入描述
1.一个用半角逗号分割的停车标识字符串，停车标识为0或1，0为空位，1为已停车。
2.停车位最多100个。

输出描述
输出一个整数记录最大距离

示例1：
输入：
1,0,0,0,0,1,0,0,1,0,1
输出：
2
*/
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <climits>
using namespace std;

int main()
{
    string input;
    getline(cin,input);
    vector<int>parking;
    stringstream ss(input);
    string token;
    while(getline(ss,token,',')){//从字符串流 ss 中读取字符，直到遇到分隔符 , 或者到达流末尾，将读取的内容存储到 token 中。
        parking.push_back(stoi(token));//stoi将字符串转换为整数
    }
    int n=parking.size();
    vector<int>carindices;
    for(int i=0;i<n;i++){
        if(parking[i]==1){
            carindices.push_back(i);
        }
    }
    int maxDist = 0;
    for (int i = 0; i < n; i++) {
       if (parking[i] == 0) {
            int leftdist=INT_MAX;
            int rightdist=INT_MAX;
      // 在已排序的车辆索引中查找第一个 >= 当前空位索引 i 的位置
      //lower_bound 找到的是第一个大于等于当前位置的车辆
      auto it=lower_bound(carindices.begin(),carindices.end(),i);
      if(it!=carindices.begin()){
        leftdist=i-*(--it);
        // --it：向前移动一位，指向左边最近的车辆
    // *(--it)：获取左边最近车辆的索引
    // i - *(--it)：计算当前空位到左边最近车辆的距离
      }
      // 找右边最近的1
            it = lower_bound(carindices.begin(), carindices.end(), i);
            if (it != carindices.end()) {
                rightdist = *it - i;
            }
            int minDist = min(leftdist, rightdist);
            if (minDist != INT_MAX) {
                maxDist = max(maxDist, minDist);
            }
    }}
    cout << maxDist << endl;

    return 0;
}