数据结构之图

1.

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

const int maxn=1e6+10;
int fa[maxn],mom[maxn],vis[maxn];
char sex[maxn];
int flag=1;

void dfs(int id,int color,int cnt) {
    if (cnt>5||id==-1||!flag) {
        return;
    }
    if (vis[id]==color) {
        flag=0;
        return ;
    }
    vis[id]=color;
    dfs(fa[id],color,cnt+1);
    dfs(mom[id],color,cnt+1);
}

int main()
{
    int n;
    int id,f,m;
    char sx;
    scanf("%d",&n);
    memset(mom,-1,sizeof(mom));
    memset(fa,-1,sizeof(fa));
    memset(vis,-1,sizeof(vis));
    while (n--) {
        scanf("%d %c %d %d",&id,&sx,&f,&m);
        sex[f]='M';
        sex[m]='F';
        fa[id]=f;
        mom[id]=m;
        sex[id]=sx;
    }
    int k;
    int v1,v2;
    scanf("%d",&k);
    while (k--) {
        scanf("%d%d",&v1,&v2);
        flag=1;
        if (sex[v1]==sex[v2]) {
            printf("Never Mind\n");
            continue;
        }
        dfs(v1,k,1);
        dfs(v2,k,1);
        if (flag) {
            printf("Yes\n");
        }
        else {
            printf("No\n");
        }
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define max 20001

struct Node{
	int to;//指向边的结点
	int val;//边的权值
	int next;//指向下一个结点的下标
} node[max];

int head[max],n,m,num = 0;
int infinite = 99999;

//建立邻接表
void add(int from,int to,int val){

	num++;
	node[num].to = to;
	node[num].val = val;
	node[num].next = head[from];
	head[from] = num;//更新head的值，当再有从from连接的点 它的下一个为 num 坐标
}

//dij算法
void dijkstra(){
	int dist[max];
	fill(dist, dist + 20001, infinite);
	int vis[max] = {0};

	for(int i = head[0]; i != 0; i = node[i].next){//这里是选取源点为0的顶点，将和其相连边的权值存进去了
		dist[node[i].to] = node[i].val;   //比如：0到1：即 node[i].to = 1表示的是顶点, node[i].val = 1 表示0到1这条边的权值为1;dist[1] = 1
	}

	vis[0] = 1;

	while(1){

		int m = -1;
		int min = infinite;

		for(int i = 0; i < n; i++){

			if(vis[i] != 1 && dist[i] < min){
				min = dist[i];
				m = i;
			}
		}

		if(m == -1){//已经遍历完了所有结点
			break;
		}

		vis[m] = 1;

		//确定m这个顶点 接下来遍历 m这个结点的链表

		for(int i = head[m]; i != 0; i = node[i].next){

			if(vis[node[i].to] != 1 && min + node[i].val < dist[node[i].to]){//vis[node[i].to] != 1如果出现 1到2 和2到1这种情况，那么当1已经遍历过，在顶点为2的这个链表中就不用再遍历了

				dist[node[i].to] = min + node[i].val;

			}
		}
	}

	for(int i = 0; i < n; i++){
		if(dist[i] != infinite){
			cout << dist[i] << ' ';
		}
	}
}

int main(){

	memset(head,0,sizeof(head));
	cin >> n >> m;

	for(int i = 0; i < m; i++){
		int from,to,val;
		cin >> from >> to >> val;
		add(from,to,val);
	}

	dijkstra();

}

#include <iostream>
using namespace std;
int q[101];
int r = -1, f = -1;
void enq(int x)
{
    q[++f] = x;
}
int deq()
{
    return q[++r];
}
int main()
{
    int cnt=0;
    int m[101][101] = { 0 };
    int in_dgr[101] = { 0 };
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        int t;
        cin >> t;
        in_dgr[i] += t;
        for (int j = 0; j < t; j++)
        {
            int t2;
            cin >> t2;
            m[t2][i] = 1;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        if (in_dgr[i] == 0)
        {
            enq(i);
            cnt++;
        }
    }
    while (r < f)
    {
        int temp = deq();
        for (int i = 1; i <= n; i++)
        {
            if (m[temp][i] == 1)
            {
                in_dgr[i]--;
                if (in_dgr[i] == 0)
                {
                    enq(i);
                    cnt++;
                }
            }
        }
    }
    if (cnt != n)cout << "0";
    else cout << "1";
}