UVA1416 Warfare And Logistics(LA4080)

首先用Dijkstra求出每对点距离；
以及每条边是否属于以某个点为单源的树上


然后枚举删除每条边:
之后对于每个单源，如果这条边在上面则重新对这个点dijkstra,
然后修改相应的边；

否则每个点到这个单源的最短距离肯定不变(在原C基础上修改)

wrong了整整一天，原来是求与源点相邻的点时忘了会有重边的情况，坑死了……

#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
using namespace std;
typedef long long LL;
const int maxn = 100+10;
const int maxm = 1000+10;

class Edge
{
    public:
    int pos, no;//no表示它来自的边的编号
    LL dis;//邻接表的边长或优先队列中到源点距离
    Edge(int pos, LL dis, int no = 0)
    {
        this->pos = pos;
        this->dis = dis;
        this->no  = no;
    }
    bool operator < (const Edge &ans)const
    {
        return dis > ans.dis;
    }
};

vector<Edge> adj[maxn];
int dis[maxn][maxn], dis1[maxn];
bool belong[maxm][maxn];//某边是否在某棵树上
bool vis[maxn], del[maxm];//del[i]这条边是否被删除了
int N, M, L;
LL C, CC, CC1;

void Init()
{
    for(int i = 1; i <= N; i++)
        adj[i].clear();
    memset(belong, false, sizeof(belong));
    memset(del, false, sizeof(del));

    int a, b, c;
    for(int i = 1; i <= M; i++)
    {
        scanf("%d%d%d", &a, &b, &c);
        adj[a].push_back(Edge(b, c, i));
        adj[b].push_back(Edge(a, c, i));
    }
}

void Dijkstra1(int dd[], int root)
{
    for(int i = 1; i <= N; i++)
    {
        vis[i] = false;
        dd[i] = -1;
    }
    dd[root] = 0;
    vis[root] = true;

    priority_queue<Edge> myQue;
    for(vector<Edge>::iterator it = adj[root].begin(); it != adj[root].end(); it++)
    {
        int u = it->pos;
        if(dd[u] == -1 || it->dis < dd[u])//可能有重边，就是这个地方让我wrong了一整天啊
        {
            dd[u] = it->dis;
            myQue.push(Edge(u, dd[u], it->no));
        }
    }
    while(!myQue.empty())
    {
        Edge ans = myQue.top();
        myQue.pop();
        int u = ans.pos;
        if(vis[u])
            continue;
        vis[u] = true;
        belong[ans.no][root] = true;//ans.no属于以root为根的树

        for(vector<Edge>::iterator it = adj[u].begin(); it != adj[u].end(); it++)
        {
            int v = it->pos;
            if(dd[v] == -1 || dd[u] + it->dis < dd[v])
            {
                dd[v] = dd[u] + it->dis;
                myQue.push(Edge(v, dd[v], it->no));
            }
        }
    }
    for(int i = 1; i <= N; i++)
        if(dd[i] == -1)
            C += L;
        else
            C += dd[i];
}

void Dijkstra2(int dd[], int root)
{
    for(int i = 1; i <= N; i++)
    {
        dd[i] = -1;
        vis[i] = false;
    }

    priority_queue<Edge> myQue;
    dd[root] = 0;
    myQue.push(Edge(root, 0));//no在进入队列后就没用了,但是进入前要判断
    while(!myQue.empty())
    {
        Edge ans = myQue.top();
        myQue.pop();
        int u = ans.pos;
        if(vis[u])
            continue;
        vis[u] = true;
        for(vector<Edge>::iterator it = adj[u].begin(); it != adj[u].end(); it++)
        {
            if(del[it->no])//这条边被删除了
                continue;
            int v = it->pos;
            if(dd[v] == -1 || dd[u] + it->dis < dd[v])
            {
                dd[v] = dd[u] + it->dis;
                myQue.push(Edge(v, dd[v]));
            }
        }
    }
    for(int i = 1; i <= N; i++)//替换相应的边
    {
        if(dis[root][i] == -1)
            CC1 -= L;
        else
            CC1 -= dis[root][i];

        if(dd[i] == -1)
            CC1 += L;
        else
            CC1 += dd[i];
    }
}

void Solve()
{
    C = 0;
    for(int i = 1; i <= N; i++)
        Dijkstra1(dis[i], i);

    CC = C;
    for(int i = 1; i <= M; i++)//枚举删除了这条边
    {
        CC1 = C;//只在原来不删除边的基础上修改变化的边
        del[i] = true;//删除这条边
        for(int j = 1; j <= N; j++)
            if(belong[i][j])//i边在以j为根的树上
                Dijkstra2(dis1, j);
        del[i] = false;
        if(CC == -1 || CC < CC1)
            CC = CC1;
    }
    printf("%lld %lld\n", C, CC);
}

int main()
{
    while(scanf("%d%d%d", &N, &M, &L) != EOF)
    {
        Init();
        Solve();
    }
    return 0;
}