hdu 1317+hdu 1535(SPFA)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1317

思路：只要在SPFA中将一个条件，就不会进入负环。那么如果有正环呢，显然退出条件是某个点入队列次数>=n，此时退出时只需判断当前点是否与n存在路径，这步可以用Floyd来实现。。。

#include<iostream>
#include<queue>
const int MAXN=110;
using namespace std;
int n;
int weight[MAXN];
int power[MAXN];
int _count[MAXN];//记录某点的入队列次数
bool map[MAXN][MAXN];
bool reach[MAXN][MAXN];//floyd判断任何两点是否可达


void Floyd(){
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                reach[i][j]=(reach[i][j]
                ||(reach[i][k]&&reach[k][j]));
            }
        }
    }
}

bool SPFA(int now){
    queue<int>Q;
    Q.push(now);
    memset(power,0,sizeof(power));
    memset(_count,0,sizeof(_count));
    power[1]=100;
    while(!Q.empty()){
        int now=Q.front();
        Q.pop();
        _count[now]++;
        if(_count[now]>=n)return reach[now][n];//如果某个点的次数超过n次，那么说明存在正环，此时只要判断这点到n点是否可达就行了
        for(int next=1;next<=n;next++){
            if(map[now][next]&&power[now]+weight[next]>power[next]
            &&power[now]+weight[next]>0){
                Q.push(next);
                power[next]=power[now]+weight[next];
            }
        }
    }
    return power[n]>0;
}

int main(){
    while(~scanf("%d",&n)&&n!=-1){
        memset(map,false,sizeof(map));
        memset(reach,false,sizeof(reach));
        for(int i=1;i<=n;i++){
            int num;
            scanf("%d%d",&weight[i],&num);
            for(int j=1;j<=num;j++){
                int k;
                scanf("%d",&k);
                map[i][k]=true;
                reach[i][k]=true;
            }
        }
        Floyd();
        if(!reach[1][n]){
            printf("hopeless\n");
        }else {
            if(SPFA(1)){
                printf("winnable\n");
            }else 
                printf("hopeless\n");
        }
    }
    return 0;
}

 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1535

思路：正向建一次图，反向建一次图，然后两次SPFA就可以了，采用vector的邻接表形式，特别好用。。。

#include<iostream>
#include<vector>
#include<queue>
const int MAXN=1000000+10;
typedef long long ll;
const ll inf=1e60;
using namespace std;
struct Node{
    int v,w;
};
vector<Node>mp1[MAXN];//正向建图
vector<Node>mp2[MAXN];//反向建图
int n,m;
ll cost[MAXN];

void SPFA(int u,vector<Node>mp[]){
    for(int i=2;i<=n;i++)cost[i]=inf;
    cost[1]=0;
    queue<int>Q;
    Q.push(u);
    while(!Q.empty()){
        int u=Q.front();
        Q.pop();
        for(int i=0;i<mp[u].size();i++){
            int v=mp[u][i].v;
            int w=mp[u][i].w;
            if(cost[v]>cost[u]+w){
                cost[v]=cost[u]+w;
                Q.push(v);
            }
        }
    }
}


int main(){
    int _case;
    scanf("%d",&_case);
    while(_case--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++){
            mp1[i].clear();
            mp2[i].clear();
        }
        for(int i=1;i<=m;i++){
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            Node p1,p2;
            p1.v=u,p2.v=v,p1.w=p2.w=w;
            mp1[u].push_back(p2);
            mp2[v].push_back(p1);
        }
        SPFA(1,mp1);//正向求一次
        ll ans=0;
        for(int i=2;i<=n;i++){
            ans+=cost[i];
        }
        SPFA(1,mp2);//反向求一次
        for(int i=2;i<=n;i++){
            ans+=cost[i];
        }
        printf("%lld\n",ans);
    }
    return 0;
}