7-46 超级玛丽

假定有n个城堡，编号为1至n，有的城堡之间有道路直接相连，有的城堡之间没有道路直接相连。马里奥现在准备从一个城堡出发前往另一个城堡，它有一个魔法棒，可以瞬时通过一条道路，即以0时间通过这条道路，但魔法棒最多只能用一次。马里奥想以最短的时间到达目的地，请编写程序为马里奥选定一条路线以及在什么地方使用魔法棒。假定所有道路为双向，保证从起点肯定能到达目的地。

#include<cstring>
#include<iostream>
#include<vector>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
 
 
const int MAXSIZE = 10000 + 1;
const int INVALID = 0x7FFFFFFF;
vector<pair<int, int>> adjacencyList[MAXSIZE];
int n, m;
int start, endPoint;
pair<int, int> edges[MAXSIZE];
 
void setDistance(int from, int to, int distance) {
    for(auto& adjacent:adjacencyList[from]) {
        if(adjacent.first == to) {
            adjacent.second = distance;
            return;
        }
    }
    adjacencyList[from].push_back({to, distance});
}
 
int getDistance(int from, int to) {
    for(auto& adjacent:adjacencyList[from]) {
        if(adjacent.first == to) {
            return adjacent.second;
        } else if(adjacent.first > to) {
            return INVALID;
        }
    }
    return INVALID;
}
 
void init() {
    scanf("%d %d %d %d", &n, &start, &endPoint, &m);
    for(int i=0;i<m;++i) {
        int from, to, distance;
        scanf("%d %d %d", &from, &to, &distance);
        adjacencyList[from].push_back({to, distance});
        adjacencyList[to].push_back({from, distance});
        edges[i] = {from, to};
    }
    for(int i=1;i<=n;++i) {
        sort(adjacencyList[i].begin(), adjacencyList[i].end(), 
             [](const auto& lhs, const auto& rhs) -> bool { return lhs.first < rhs.first; });
    }
}
 
// 普通的Dijkstra已经不能在战场上挥斥方遒了
vector<int> dijkstra(int startPoint) {
    vector<int> distance(n+1, INVALID);
    vector<bool> visited(n+1, false);
    for(int i=1;i<=n;++i) {
        distance[i] = getDistance(startPoint, i);
    }
    distance[startPoint] = 0;
    visited[startPoint] = true;
    for(int j=0;j<n;++j) {
        int minDis = INVALID;
        int minPoint = -1;
        for(int i=1;i<=n;++i) {
            if(!visited[i] && distance[i] < minDis) {
                minDis = distance[i];
                minPoint = i;
            }
        }
        if(minPoint == -1) break;
        visited[minPoint] = true;
        for(int i=1;i<=n;++i) {
            int curDis = getDistance(i, minPoint);
            if(!visited[i] && curDis != INVALID && curDis + minDis < distance[i]) {
                distance[i] = curDis + minDis;
            }
        }
    }
    return distance;
}
 
struct Node {
    int point, cost;
    
    bool operator < (const Node & rhs) const {
        if(cost==rhs.cost) return point<rhs.point;  
        return cost > rhs.cost;  
    }
};
 
// 堆优化Dijkstra算法简单好用
vector<int> dijkstra_heap(int startPoint) {
    int i = 0;
    vector<int> dis(n+1, INVALID);
    dis[startPoint] = 0;
    // 用优先队列优化
    priority_queue<Node> q;
    q.push({startPoint,dis[startPoint]});
    while(!q.empty()) {
        Node node = q.top();
        q.pop();
        for(i=0;i<adjacencyList[node.point].size();i++) {
            auto y = adjacencyList[node.point][i];
            int point = y.first;
            int cost = y.second;
            if(dis[point]>node.cost+cost) {
                dis[point]=node.cost+cost;
                q.push({point,dis[point]});
            }
        }
    }
    return dis;
}
 
int main() {
    init();
    int minTime = INVALID;
    int changeStart = -1;
    vector<int> startInStart = dijkstra_heap(start);
    vector<int> startInEnd = dijkstra_heap(endPoint);
    for(int i=0;i<m;++i) {
        int from = edges[i].first;
        int to = edges[i].second;
        if(startInStart[from] == INVALID || startInEnd[to] == INVALID) {
            continue;
        }
        int time = startInStart[from] + startInEnd[to];
        if(time < minTime || (time == minTime && min(from, to) < changeStart)) {
            minTime = time;
            changeStart = min(from, to);
        }
    }
    cout<<minTime<<" "<<changeStart<<endl;
    return 0;
}

7-47 排列论文

给定编号为1至n的n篇论文，以及m个形如d, u (1≤d,u≤n,d=u)的引用关系，表示论文论文d中定义的一个名词在论文u中被引用。现在要对这n篇论文重新排列，排列方案须满足如下要求：一篇论文引用的名词必须在排在他前面的论文中被定义过。

请编写程序粗略计算都有多少种满足要求的方案，如果无满足要求的方案则输出0，如果有唯一方案则输出1，如果有多种方案则输出2。

#include<iostream>
#include<queue>
#include<vector>
using namespace std;
int func(vector<vector<int>> &edge,vector<int>& in){
	if(edge.size()==2) return 1;
	else{
		int flag=0;
		queue<int> q;
		for(int i=1;i<edge.size();i++){
			if(in[i]==0){
				q.push(i);
			}
		}
		if(q.size()==0) return 0;
		int sum=0;
		while(!q.empty()){
			int n=q.size();
			sum+=n;
			if(n>1) flag=1;
			while(n--){
				int t=q.front();
				q.pop();
				for(auto &e:edge[t]){
					in[e]-=1;
					if(in[e]==0){
						q.push(e);
					}
				}
			}
		}
		if(sum<edge.size()-1) return 0;
		if(flag) return 2;
		return 1;
	}
} 
int main(){
	int n,m,a,b;
	while(cin>>n>>m){
		vector<vector<int>> edge(n+1);
		vector<int> in(n+1,0);
		while(m--){
			cin>>a>>b;
			edge[a].push_back(b);
			in[b]+=1;
		}
		cout<<func(edge,in)<<endl;
	}
} 

7-48 二叉树最长匹配前后缀路径

假定二叉树结点值为不等于0的整数。我们将二叉树中以根结点为起点、非叶结点为终点的路径称为“前缀路径”，以非根结点为起点、叶结点为终点的路径称为“后缀路径”。我们称前缀路径p和后缀路径q为最长匹配前后缀路径，如果p和q满足下列条件：

（1）路径p和q同在一条以根为起点、以叶为终点的路径里；

（2）路径p和q包含的结点序列值相等；

（3）路径p和q是整个二叉树中所有满足条件（1）（2）的最长者

#include<iostream>
#include<vector>
using namespace std;
struct Node{
	int val;
	struct Node* left;
	struct Node* right;
	Node(int n){
		val=n;
		left=nullptr;
		right=nullptr;
	}
};
void create(Node*& root){
	int t;
	cin>>t;
	if(t==0) return ;
	root=new Node(t);
	create(root->left);
	create(root->right);
}
void get(Node* root,vector<vector<int>>&v,vector<int>& temp){
	temp.push_back(root->val);
	if(!root->left&&!root->right) v.push_back(temp);
	if(root->left) get(root->left,v,temp);
	if(root->right)get(root->right,v,temp);
	temp.pop_back();
}
int func(Node* root){
	if(root==nullptr) return -1;
	vector<vector<int>> v;
	vector<int> temp;
	get(root,v,temp);
	int ret=-1;
	for(auto &vv:v){
		vector<int> next(vv.size());
		next[0]=0;
		int j=0;
		for(int i=1;i<vv.size();i++){
			while(j!=0&&vv[i]!=vv[j]) j=next[j-1];
			if(vv[i]==vv[j]) j++;
			next[i]=j;
		}
		if(ret==-1||ret<next[vv.size()-1]-1) ret=next[vv.size()-1]-1;
	}
	return ret;
}
int main(){
	int t;
	cin>>t;
	while(t--){
		Node* root=nullptr;
		create(root);
		cout<<func(root)<<endl;
	}
	return 0;
}

7-49 特殊最小成本修路

n个城镇之间目前有一些道路连接，但道路都是年久失修的土道。现在政府准备将其中一些土道改造为标准公路，希望标准公路能够将所有城镇连通且总成本最小，但其中有一个城镇比较特殊，受地形等限制，最多只能有两条标准公路通过该镇。请编写程序，找出一种满足上述条件的、总成本最小的改造方案，若不存在改造方案，则亦能识别。假定道路是双向的。

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

typedef struct {
    int u;
    int v;
    int w;
} Road;

Road road[51];
int f[51];

bool cmp(Road r1, Road r2) { return r1.w < r2.w; }

void init() {
    for (int i = 0; i < 51; i++) {
        f[i] = i;
    }
}

int find(int x) {
    if (x == f[x])
        return x;
    return f[x] = find(f[x]);
}

int merge(int x, int y) {
    int a = find(x);
    int b = find(y);
    if (a != b) {
        f[b] = a;
        return 1;
    }
    return 0;
}

int main() {
    int n, v, e;
    while (scanf("%d %d %d", &n, &v, &e) != EOF) {
        init();
        for (int i = 0; i < e; i++) {
            scanf("%d %d %d", &road[i].u, &road[i].v, &road[i].w);
        }
        int cnt = 0, sum = 0, num = 0;
        sort(road, road + e, cmp);
        for (int i = 0; i < e; i++) {
            if ((road[i].u == v || road[i].v == v) && cnt < 2) {
                if (merge(road[i].u, road[i].v)) {
                    sum += road[i].w;
                    cnt++;
                    num++;
                }
            } else if (road[i].u != v && road[i].v != v) {
                if (merge(road[i].u, road[i].v)) {
                    sum += road[i].w;
                    num++;
                }
            }
            if (num == n - 1)
                break;
        }
        if (num == n - 1 && cnt <= 2)
            printf("%d\n", sum);
        else
            printf("-1\n");
    }
    return 0;
}

7-50 扫雷游戏

扫雷是一款经典游戏，也是Windows操作系统最早引入的一款游戏，其最为经典的版本是Windows XP操作系统自带的扫雷游戏，曾风靡一个时代，是一代人的永恒记忆。

简单来说，其游戏界面由n行m列方格组成，其中k个方格后面隐藏着地雷。当用户点击一个方格时：

（1）如果该方格后面隐藏着地雷，则游戏结束，用户失败。

（2）如果该方格不是地雷，则该方格被打开：

• 若该方格与地雷相邻（即该方格上、下、左、右、左上、左下、右上、右下相邻的8个方格内有地雷），则该方格处显示一个数字，表示其周围8个方格中的地雷数。
• 若该方格未与地雷相邻（即该方格周围8个格子内没有地雷），则该方格的未被打开的邻居（即与该方格上、下、左、右、左上、左下、右上、右下相邻的方格）、邻居的邻居、邻居的邻居的邻居……都会被逐级打开，直到某方格与地雷相邻。这期间每个方格的处理方式同（2）。

（3）当所有没隐藏地雷的方格均被打开（即所有没打开的方格后都有地雷），则游戏结束，用户获胜。

请编写程序从初始界面开始，对于一系列用户的点击，求出点击之后的游戏界面。未打开的方格用-1表示，即游戏初始时为n行m列-1。已打开且未与雷相邻的方格用0表示，已打开且与雷相邻的方格用数字a (1≤ a ≤ 8)表示，即与之相邻的地雷数。

#include<stdio.h>
#define Rows 22
#define Cols 22
int n,m,k,l;
int data[Rows][Cols];  //数据数组 
int game[Rows][Cols];  //玩家界面数组 

void Init();
void disp();
void dispdata();
void setboom(int a,int b);
void setnumber();
void swap(int x,int y);
int tongji();

//初始化玩家界面 
void Init()
{
	for (int i = 0; i <Rows; i++)
	{
		for (int j = 0; j <Cols; j++)
		{
			game[i][j] = -1;
		}
	}
	
} 

//打印玩家界面 
void dispgame()
{
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			printf("%d ",game[i][j]);
		}
		printf("\n");
	}
}

//打印后台数据 
void dispdata(){
	for(int i=0;i<=n+1;i++){
		for(int j=0;j<=m+1;j++){
			printf("%d ",data[i][j]);
		}
		printf("\n");
	}
}

//设置炸弹 
void setboom(int a,int b)
{
	data[a+1][b+1]=-1;   //data数组打印出来的是从下标1开始的 
} 

//将后台数据与游戏界面交互 
void swap(int x,int y)
{
	if(game[x][y]!=-1||x<1||x>n||y<1||y>m){
        return ;
    }else{
        game[x][y]=data[x][y];
    } 
	if(game[x][y]==0){
		for(int i=x-1;i<=x+1;i++){
			for(int j=y-1;j<=y+1;j++){
				swap(i,j);
			}
		} 
	 }
}

//设置后台元素数据 
void setnumber()
{
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(data[i][j]!=-1)
			{
				if(data[i-1][j-1]==-1)
				   data[i][j]++;
				   
				if(data[i-1][j]==-1)
				   data[i][j]++;
				   
				if(data[i-1][j+1]==-1)
				   data[i][j]++;
				   
				if(data[i][j-1]==-1)
				   data[i][j]++;
				   
				if(data[i][j+1]==-1)
				   data[i][j]++;
				   
				if(data[i+1][j-1]==-1)
				   data[i][j]++;
				   
				if(data[i+1][j]==-1)
				   data[i][j]++;
				   
				if(data[i+1][j+1]==-1)
				   data[i][j]++; 
			}
		}
	} 
}

//统计还有多少个位置没开
int tongji()
{
	int sum=0;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(game[i][j]==-1){
				sum++;
			} 
		}
	}
	return sum;
}


int main()
{
	Init();
	scanf("%d %d %d %d",&n,&m,&k,&l);//输入数据 
	if(n>=0&&n<=20&&m>=0&&m<=20&&k>=0&&k<=50&&l>=0&&l<=200){
    //将炸弹保存进后台数组 
	for(int i=0;i<k;i++){
		int a=0,b=0;
		scanf("%d %d",&a,&b);
        if(a>=0&&a<=n&&b>=0&&b<=m){
            setboom(a,b);
        }
	} 
        
	//设置后台元素 
    setnumber();
    
    //玩家操作
    int x,y;
	for(int i=0;i<l;i++){
		scanf("%d %d",&x,&y);
        //判断是否踩到雷
        if(x>=0&&x<=n&&y>=0&&y<=m){
          if(data[x+1][y+1]==-1){
			printf("You lose\n"); 
			break;
		}
        //判断重复输入
        if(game[x+1][y+1]!=-1){
            continue;
        }else{
            swap(x+1,y+1);
            dispgame();
            if((tongji())==k){
               printf("You win\n");
               break;
            }else{
                printf("\n");
            }
        }
    }
  }
}
	return 0;
}