4.30 练习

迷宫问题

描述

定义一个二维数组 N*M ，如 5 × 5 数组下所示：

int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。

数据范围：2≤n,m≤10  ， 输入的内容只包含0≤val≤1 

输入描述：

输入两个整数，分别表示二维数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

输出描述：

左上角到右下角的最短路径，格式如样例所示。

示例1

输入：

5 5
0 1 0 0 0
0 1 1 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出：

(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

解题：递归+回溯

#include <iostream>
#include <utility>
#include <vector>
using namespace std;
vector<pair<int,int>> result;
void backtracking(vector<vector<int>> &mat,int rows,int cols,int i,int j,vector<pair<int,int>> &path)
{
    
    //加入路径
    path.push_back(make_pair(i,j));
    mat[i][j]=1;//表示该节点已经访问过，不能再次访问
    //终止条件---写在加入路径的下面，是为了保证右下角的点加入路径
    if(i==rows-1 && j==cols-1)
    {
        result=path;
        return;
    }
    //只能向左右上下进行搜索
    //左
    if(i-1>=0 && mat[i-1][j]==0)
        backtracking(mat,rows,cols,i-1,j,path);
    //右
    if(i+1<rows && mat[i+1][j]==0)
        backtracking(mat,rows,cols,i+1,j,path);
    //上
    if(j-1>=0 && mat[i][j-1]==0)
        backtracking(mat,rows,cols,i,j-1,path);
    //下
    if(j+1<cols && mat[i][j+1]==0)
        backtracking(mat,rows,cols,i,j+1,path);
    path.pop_back();//回溯
    mat[i][j]=0;
}
int main() {
    int rows,cols;
    
    while(cin>>rows>>cols)
    {
        vector<vector<int>> mat(rows,vector<int>(cols));
        for(int i=0;i<rows;i++)
        {
            for(int j=0;j<cols;j++)
            {
                cin>>mat[i][j];
            }
        }
        vector<pair<int,int>> path;
        backtracking(mat,rows,cols,0,0,path);
        for(int i=0;i<result.size();i++)
        {
            cout<<"("<<result[i].first<<","<<result[i].second<<")"<<endl;
        }
    }
    return 0;
}

名字的漂亮度

描述

给出一个字符串，该字符串仅由小写字母组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个不同字母拥有相同的“漂亮度”。字母忽略大小写。

给出多个字符串，计算每个字符串最大可能的“漂亮度”。

本题含有多组数据。

数据范围：输入的名字长度满足 1≤n≤10000 

输入描述：

第一行一个整数N，接下来N行每行一个字符串

输出描述：

每个字符串可能的最大漂亮程度

示例1

输入：

2
zhangsan
lisi

输出：

192
101

说明：

对于样例lisi，让i的漂亮度为26，l的漂亮度为25，s的漂亮度为24，lisi的漂亮度为25+26+24+26=101.   

#include <iostream>
#include <map>
using namespace std;

int main() {
    int n;
    string  str;
    cin >> n;
    while (n--) 
    {
        cin >> str;
        ///获得漂亮度
        map<char, int> cnt; //统计字符出现的次数
        for (int i = 0; i < str.size(); i++) {
            if (isalpha(str[i])) {
                char c = tolower(str[i]); //将大写字母转为小写字母
                cnt[c]++;
            }
        }
        int sum = 0;
        int max_cnt = 0;//最大出现次数
        for (auto it = cnt.begin(); it != cnt.end(); it++) {
            max_cnt = max(max_cnt, it->second);
        }
        int beauty = 26;//最大漂亮度为26
        for (int i = max_cnt; i >= 1; i--) 
        {
            for (auto it = cnt.begin(); it != cnt.end(); it++) 
            {
                if (it->second == i) {
                    sum += i * beauty;
                    beauty--;
                }
            }
        }
        cout<<sum<<endl;

    }
    return 0;
}

从单向链表中删除指定值的节点

描述

输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。

链表的值不能重复。

构造过程，例如输入一行数据为:

6 2 1 2 3 2 5 1 4 5 7 2 2

则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示:

1 2 表示为

2->1

链表为2->

3 2表示为

2->3

链表为2->3->1

5 1表示为

1->5

链表为2->3->1->5

4 5表示为

5->4

链表为2->3->1->5->4

7 2表示为

2->7

链表为2->7->3->1->5->4

最后的链表的顺序为 2 7 3 1 5 4

最后一个参数为2，表示要删掉节点为2的值

删除 结点 2

则结果为 7 3 1 5 4

数据范围：链表长度满足1≤n≤1000  ，节点中的值满足 0≤val≤10000 

测试用例保证输入合法

输入描述：

输入一行，有以下4个部分：

1 输入链表结点个数
2 输入头结点的值
3 按照格式插入各个结点
4 输入要删除的结点的值

输出描述：

输出一行

输出删除结点后的序列，每个数后都要加空格

示例1

输入：

5 2 3 2 4 3 5 2 1 4 3

输出：

2 5 4 1

说明：

形成的链表为2->5->3->4->1
删掉节点3，返回的就是2->5->4->1  

#include <iostream>
#include <utility>
#include <vector>
#include <bits/stdc++.h>
using namespace std;

int main() 
{
    int n, val;
    cin >> n; //结点数目
    cin >> val; //头结点的值
    int a, b;
    //创建一个单向链表
    forward_list<int> list;
    list.push_front(val);
    vector<pair<int, int>> path;
    for (int i = 1; i < n ; i++) {
        cin >> a >> b;
        auto it=find(list.begin(),list.end(),b);
        list.insert_after(it,a);
    }
    int delval;
    cin>>delval;//要删除的结点
    list.remove(delval);
    for(auto it=list.begin();it!=list.end();it++)
    {
        cout<<*it<<" ";
    }
    return 0;
}