HDU 6582 Path

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 244    Accepted Submission(s): 50

Problem Description

Years later, Jerry fell in love with a girl, and he often walks for a long time to pay visits to her. But, because he spends too much time with his girlfriend, Tom feels neglected and wants to prevent him from visiting her.
After doing some research on the neighbourhood, Tom found that the neighbourhood consists of exactly  n houses, and some of them are connected with directed road. To visit his girlfriend, Jerry needs to start from his house indexed 1 and go along the shortest path to hers, indexed n. 
Now Tom wants to block some of the roads so that Jerry has to walk longer to reach his girl's home, and he found that the cost of blocking a road equals to its length. Now he wants to know the minimum total cost to make Jerry walk longer.
Note, if Jerry can't reach his girl's house in the very beginning, the answer is obviously zero. And you don't need to guarantee that there still exists a way from Jerry's house to his girl's after blocking some edges.

 

Input

The input begins with a line containing one integer  T(1≤T≤10), the number of test cases.
Each test case starts with a line containing two numbers n,m(1≤n,m≤10000), the number of houses and the number of one-way roads in the neighbourhood.
m lines follow, each of which consists of three integers x,y,c(1≤x,y≤n,1≤c≤109), denoting that there exists a one-way road from the house indexed x to y of length c.

 

Output

Print  T lines, each line containing a integer, the answer.

 

Sample Input

1

3 4

1 2 1

2 3 1

1 3 2

1 3 3

 

Sample Output

3

 

Source

2019 Multi-University Training Contest 1

 

Recommend

We have carefully selected several similar problems for you:   6590  6589  6588  6587  6586 

 

吐槽

　　這么過分，一定要發朋友圈博客。杭電多校第一場(見上面那個source)，AC 1 題收場，就是這題。下兩場可以休息了。本來第四題二分（https://www.cnblogs.com/wawcac-blog/p/11229277.html）也不難，但自己就是想不到。感覺自己現在還只會做板題。別人覺得難度更低的題，我就是想不出來。CF還是要接着打啊……

題意

　　原題在這https://www.cnblogs.com/wawcac-blog/p/7012556.html，上學路線的第二問，思路也在那了。只是數據范圍增大了20倍，於是把Floyd改成dijkstra，幾個int改成long long。理論上dinic是要T的，但它就是AC了……

源代碼

#include <queue>
#include <stdio.h>
#include <string.h>
#include <algorithm>

int T;
int n, m;

struct Edge
{
    int nxt, to;
    long long w;
} e[10010], f[10010];
int cnt = 1, head[10010], fcnt = 1, fhead[10010]; //正向圖與反向圖
void add(int u, int v, long long w)
{
    e[cnt] = {head[u], v, w};
    head[u] = cnt++;
    f[fcnt] = {fhead[v], u, w};
    fhead[v] = fcnt++;
}

long long dis[10010], fdis[10010];
bool vis[10010];
struct DijkHeap
{
    int u;
    long long d;
    bool operator<(const DijkHeap &a) const
    {
        return d > a.d;
    }
} dijktemp;
void dijkstra()
{
    std::priority_queue<DijkHeap> q;
    memset(dis, 0x7f, sizeof(long long) * (n + 2));
    memset(vis, 0, sizeof(bool) * (n + 2));
    dis[1] = 0;
    q.push({1, 0});
    while (!q.empty())
    {
        dijktemp = q.top();
        q.pop();
        int u = dijktemp.u;
        long long d = dijktemp.d;
        vis[u] = 1;
        for (int i = head[u]; i; i = e[i].nxt)
        {
            int v = e[i].to;
            if (vis[v])
                continue;
            if (dis[v] > e[i].w + d)
            {
                dis[v] = e[i].w + d;
                q.push({v, dis[v]});
            }
        }
    }

    memset(fdis, 0x7f, sizeof(long long) * (n + 2));
    memset(vis, 0, sizeof(bool) * (n + 2));
    fdis[n] = 0;
    q.push({n, 0});
    while (!q.empty())
    {
        dijktemp = q.top();
        q.pop();
        int u = dijktemp.u;
        long long d = dijktemp.d;
        vis[u] = 1;
        for (int i = fhead[u]; i; i = f[i].nxt)
        {
            int v = f[i].to;
            if (vis[v])
                continue;
            if (fdis[v] > f[i].w + d)
            {
                fdis[v] = f[i].w + d;
                q.push({v, fdis[v]});
            }
        }
    }
}

struct WEdge//最短路圖
{
    int nxt, to;
    long long flow;
} we[20010];
int whead[10010] = {0}, wcnt = 2;
void wadd(int u, int v, long long f)
{
    we[wcnt] = {whead[u], v, f};
    whead[u] = wcnt++;
    we[wcnt] = {whead[v], u, 0};
    whead[v] = wcnt++;
}

int dep[10010] = {0};
bool bfs()
{
    memset(dep, 0, sizeof(int) * (n + 2));
    std::queue<int> q;
    dep[1] = 1;
    q.push(1);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        for (int i = whead[u]; i; i = we[i].nxt)
        {
            long long v = we[i].to;
            if (!dep[v] && we[i].flow)
            {
                dep[v] = dep[u] + 1;
                q.push(v);
            }
        }
    }
    return dep[n] != 0;
}

long long dfs(int u, long long fflow)
{
    if (u == n || fflow == 0LL)
        return fflow;
    long long sum = 0;
    for (int i = whead[u]; i; i = we[i].nxt)
    {
        int v = we[i].to;
        if (dep[v] == dep[u] + 1 && we[i].flow)
        {
            long long delta = dfs(v, std::min(fflow - sum, we[i].flow));
            sum += delta;
            we[i].flow -= delta;
            we[i ^ 1].flow += delta;
            if (fflow <= sum)
                break;
        }
    }
    if (!sum)
        dep[u] = -1;
    return sum;
}

long long dinic()
{
    long long ans = 0;
    while (bfs())
    {
        while (long long temp = dfs(1, 0x7f7f7f7f7f7f7f7f))
            ans += temp;
    }
    return ans;
}

void init()
{
    cnt = fcnt = 1;
    wcnt = 2;
    memset(head, 0, sizeof(int) * (n + 2));
    memset(fhead, 0, sizeof(int) * (n + 2));
    memset(whead, 0, sizeof(int) * (n + 2));
}

int main()
{
    //freopen("test.in","r",stdin);
    scanf("%d", &T);
    while (T--)
    {
        init();
        scanf("%d%d", &n, &m);
        for (int i = 1, u, v, w; i <= m; i++)
        {
            scanf("%d%d%d", &u, &v, &w);
            add(u, v, (long long)w);
        }
        dijkstra();
        for (int u = 1; u <= n; u++)
        {
            for (int i = head[u]; i; i = e[i].nxt)
            {
                int v = e[i].to;
                if (dis[u] + e[i].w + fdis[v] == dis[n])
                {
                    wadd(u, v, e[i].w);
                    //printf("***%d   %d   %lld\n", u, v, e[i].w);
                }
            }
        }
        printf("%lld\n", dinic());
    }
    return 0;
}