备战快速复习--day11

PAT A1076 

BFS的题，题不难，有几个注意点

• 首先，读懂题意，下面每行的是被转发的，比如在数据1的行里面出现了4，是4发布的内容被1转发了
• ans里面不包括源头，但是while里面带循环第一次出队列有，所以要从ans=-1开始，另外是出栈的时候计数
• 第一个点的ceng是0
• 在判断的时候，只能加没入过队的（入队改vis），然后在判断层的时候，能继续扩张的都是ceng<=len-1的，然后他们扩张ceng=len的，之后这些不需要在扩张

#include<iostream>
#include<string.h>
#include<queue>
using namespace std;
int n,l,k;
int G[1005][1005];//一是被转发的，是源头
bool vis[1005]={false};
struct node{
    int num;
    int ceng;
    node(int a,int b)
    {
        num=a;
        ceng=b;
    }
};
int BFS(int num)
{
    memset(vis,0,sizeof(vis));
    int ans=-1;//发信息的本体不算在ans里面，在top里面计算了要去掉
    vis[num]=true;
    queue<node>q;
    node tempnode=node(num,0);
    q.push(tempnode);
    while(!q.empty())
    {
        ans++;
        node top=q.front();
        q.pop();
        for(int i=1;i<=n;i++)
        {
            if(vis[i]==false && G[top.num][i]>0 && top.ceng<l)//最后可以进来的是ceng=l.前面最多l-1，才能保证l
            {
                q.push(node(i,top.ceng+1));
                vis[i]=true;
            }
        }
    }
    return ans;
}
int main()
{
    cin>>n>>l;
    memset(G,0,sizeof(G));
    for(int i=1;i<=n;i++)
    {
        int temp,num;
        cin>>temp;
        for(int j=1;j<=temp;j++)
        {
            cin>>num;
            G[num][i]=1;
        }
    }
    cin>>k;
    for(int i=1;i<=k;i++)
    {
        int tempnum;
        cin>>tempnum;
        cout<<BFS(tempnum)<<endl;
    }
    return 0;
}

 注意node p=node(1,2);这种初始化

注意 int d[100]={0}是全部赋值成0，int d[100]={1}只有第一个数字被赋值成1

全部赋值成1用fill,fill(a,a+n,num)赋值区间左闭右开。(注意fill要在d[s]=0之前)

Dijkstra-----解决单源最短路，不能有副边权，一个起点，这个点到其他所有点的最短值都可求得

如果题给的无向图，g[a][b]和g[b][a]同时赋值和删除

在Dijkstra中，维护d数组和v数组。每次选中未被访问的离起始点最近的点u，通过u更新其他点的d数值，到d不再更新的时候停止。

实际操作中，每次选中了u，需要访问所有点，从里面选出来没访问，右边的判断是否要更新。选中u的过程最多要n次，所以是里外两次循环。

首先选u，修改u的vis，再更新dis供下次使用。

模板代码

#include<iostream>
using namespace std;
int n,m,s;//n个点m个边s是起点
int G[100][100]={0};
bool visit[100]={false};
int d[100]={0};
int ans[100];
int ansnum=0;
void Dijkstra(int x)
{
    fill(d,d+n,1000);
    d[x]=0;
    for(int i=0;i<n;i++)
        cout<<d[i]<<endl;
    for(int i=0;i<n;i++)
    {
        int u=-1;
        int minnum=10000;
        for(int j=0;j<n;j++)
        {
            if(d[j]<minnum && visit[j]==false)
            {
                minnum=d[j];
                u=j;
            }
        }
        if(u==-1)
            return;
        visit[u]=true;
        cout<<u<<" "<<d[u]<<endl;
        for(int j=0;j<n;j++)
        {
            if(G[u][j]>0 && visit[j]==false)
                d[j]=min(d[j],d[u]+G[u][j]);
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    int temp1,temp2,temp3;
    for(int i=1;i<=m;i++)
    {
        cin>>temp1>>temp2>>temp3;
        G[temp1][temp2]=temp3;
    }
    Dijkstra(s);
    for(int i=0;i<n;i++)
        cout<<d[i]<<" ";
    return 0;
}

 PAT A1003

这个是求两点间最短路，另外要求求出最短路径条数和最短路上点权和max

• 额外开num和sumres标记，num[s]是1，sumres[s]为rescue[s]
• 遇到更小d更新，num[j]=num[u]，是覆盖，因为原来的数字就没有意义了
• 遇到最小d更新，点权覆盖为新的sum[u]+res[j]，前面的无论多大，不是最短路都没有意义
• 遇到相同的情况，不能把点权更大作为判断条件之一，因为即使点权不变少，最短路径数也会变化，这时候num[j]+=num[u]
• 遇到相同的情况，如果判断出点权更大了，修改为sum[u]+res[j]
• fill的头文件就是#include<iostream>
• fill要在给s赋值的一系列之前完成

#include<iostream>
#include<string.h>
using namespace std;
int n,m,c1,c2;
int G[510][510]={0};//存路径
bool visit[510]={false};
int d[510]={0};
int rescue[1000]={0};
int sumres[1000]={0};
int num[1000]={0};
void Dijkstra(int s)
{
    sumres[s]=rescue[s];
    fill(d,d+n,1e6);
    d[s]=0;
    num[s]=1;
    for(int i=0;i<n;i++)
    {
        int u=-1,minnum=1e6;
        for(int j=0;j<n;j++)
        {
            if(visit[j]==false && d[j]<minnum)
            {
                u=j;
                minnum=d[j];
            }
        }
        if(u==-1)
            return;
        visit[u]=true;
        for(int j=0;j<n;j++)
        {
            if(visit[j]==false && G[u][j]>0)
            {
                if(d[j]>d[u]+G[u][j])
                {
                    d[j]=d[u]+G[u][j];
                    sumres[j]=rescue[j]+sumres[u];
                    num[j]=num[u];
                }
                else if(d[j]==d[u]+G[u][j])
                {
                    if(sumres[j]<sumres[u]+rescue[j])
                        sumres[j]=sumres[u]+rescue[j];
                    num[j]+=num[u];
                }
            }
        }
    }
}
int main()
{
    cin>>n>>m>>c1>>c2;
    for(int i=0;i<=n-1;i++)
        cin>>rescue[i];
    int temp1,temp2,temp3;
    for(int i=1;i<=m;i++)
    {
        cin>>temp1>>temp2>>temp3;
        G[temp1][temp2]=G[temp2][temp1]=temp3;
    }
    Dijkstra(c1);
    cout<<num[c2]<<" "<<sumres[c2]<<endl;
    return 0;
}