C++博客-夜幻梦回-文章分类-最小生成树||最短路

本校oj马哥题，

火碳黑 — Mon, 21 Mar 2011 01:36:00 GMT

本校网络赛某一题。豪哥用动态mst来形容。
题解：对一个mst，随便新加入的边，求更优的mst
每个mst中的子mst可能构成不同，但值一定不变，那么新边e[u,v]的加入，将mst分成三部分，以u跟v之间割为一份M，mst去掉M后以u为根的U，和以v为根的V。
e[u,v]对U跟V没影响，只影响了M（M跟e肯定构成环H），所以只需要在H中寻找最大的边删除即可。

#include <stdio.h>
#include <stdlib.h>
#define inf 1000000000
#define maxn 1010
int dis[maxn], visit[maxn], map[maxn][maxn], path[maxn], hash[maxn][maxn];
int n, flag, th;
struct T
{
    int u, v, w, next;
}fn[maxn * maxn];
struct R
{
    int v, w;
}p[maxn];
int g[maxn];
void Set()
{
    int i, j;
    for (i = 0; i <= n; i++)
    {
        dis[i] = inf, visit[i] = 0, path[i] = 0, g[i] = -1;
    }
}
//无向图邻接表加边
void add(int u, int v, int w)
{
    fn[th].u = u, fn[th].v = v, fn[th].next = g[u], fn[th].w = w, g[u] = th++;
    fn[th].u = v, fn[th].v = u, fn[th].next = g[v], fn[th].w = w, g[v] = th++;
}
//无向图邻接表删边
void del(int u, int v)
{
    int i, j;
    i = g[u];
    if (i != -1)
    {
        if (fn[i].v == v)
        {
            g[u] = fn[i].next;
        }
        else
        {
            for (j = fn[i].next; j != -1; j = fn[j].next, i = fn[i].next)
            {
                if (fn[j].v == v)
                {
                    fn[i].next = fn[j].next;
                    break;
                }
            }
        }
    }
    i = g[v];
    if (i != -1)
    {
        if (fn[i].v == u)
        {
            g[v] = fn[i].next;
        }
        else
        {
            for (j = fn[i].next; j != -1; j = fn[j].next, i = fn[i].next)
            {
                if (fn[j].v == u)
                {
                    fn[i].next = fn[j].next;
                    break;
                }
            }
        }
    }
}
//邻接矩阵普利姆
int Prime()
{
    Set();
    int i, j, pre, next, sum = 0, min;
    for (i = 0, pre = 1; i < n - 1; i++)
    {
        visit[pre] = 1, min = inf;
        for (j = 1; j <= n; j++)
        {
            if (visit[j] == 0)
            {
                if (dis[j] > map[pre][j])
                {
                    dis[j] = map[pre][j];
                    path[j] = pre;//更新或保存j在mst中的父节点
                }
                if (min > dis[j])
                {
                    min = dis[j];
                    next = j;
                }
            }
        }
        pre = next;
        sum += dis[pre];
    }

    for (i = 1; i <= n; i++)
    {
        if (path[i])//hash用来判断hash[i][j]是否是mst的边
        {
            hash[i][path[i]] = hash[path[i]][i] = 1;
        }
    }
    for (i = 1; i <= n; i++)//将mst用邻接表重新构图
    {
        for (j = 1; j < i; j++)
        {
            if (hash[i][j])
            {
                add(i, j, map[i][j]);
            }
        }
    }
    return sum;
}
inline void dfs(int u)
{
    visit[u] = 1;
    int i;
    for (i = 1; i <= n; i++)
    {
        if (!visit[i] && map[u][i] != inf)
        {
            dfs(i);
        }
    }
}
void find(int u, int f)//邻接表mst中搜寻u到f之间的边
{
    visit[u] = 1;
    if (u == f)
    {
        flag = 1;
        return;
    }
    int i, v;
    for (i = g[u]; i != -1; i = fn[i].next)
    {
        v = fn[i].v;
        if (!visit[v])
        {
            p[v].v = u, p[v].w = fn[i].w;
            find(v, f);
            if (flag)
            {
                return;
            }
        }
    }
}
void show()
{
    int i, j;
    for (i = 1; i <= n; i++)
    {
        printf("%d:", i);
        for (j = g[i]; j != -1; j = fn[j].next)
        {
            printf(" [%d,%d]", fn[j].v, fn[j].w);
        }
        printf("\n");
    }
}
int main()
{
    //freopen("net.in", "r", stdin);
    //freopen("ex.out", "w", stdout);
    int t, m, i, j, sign, u, v, w, sum, ca = 0;
    scanf("%d", &t);
    while (t--)
    {
        ca++;
        th = 0;
        printf("Case %d:\n", ca);
        scanf("%d%d", &n, &m);
        sign = 1;
        for (i = 1; i <= n; i++)
            for (j = 1; j <= n; j++)
            {
                map[i][j] = inf, hash[i][j] = 0;
            }
        while (m--)
        {
            scanf("%d%d%d", &u, &v, &w);
            if (sign)//图没连同时，继续加边并判断加边后是否连同，如果是，求mst并用邻接表重构mst
            {
                if (map[u][v] > w)
                {
                    map[u][v] = map[v][u] = w;
                    for (i = 1; i <= n; i++) visit[i] = 0;
                    dfs(1);
                    for (i = 1; i <= n && visit[i]; i++);
                    if (i == n + 1)
                    {
                        sign = 0;
                        sum  = Prime();
                    }
                }
                if (sign)
                {
                    printf("The net still undone\n");
                }
                else
                {
                    printf("%d\n", sum);
                }
            }
            else//图已连同，则完后所有加边，图都是连同的，树课随着加入的边调整，是mst的值更小
            {
                flag = 0;
                for (i = 1; i <= n; i++)
                {
                    visit[i] = 0, p[i].v = -1;
                }
                find(u, v);
                for (i = v, j = v; i != u; i = p[i].v) //在u跟v直接寻找最大边。因为用find(u,v),所以i的前驱节点为path[i].v
                {
                    if (p[j].w < p[i].w)
                    {
                        j = i;
                    }
                }
                if (p[j].w > w)
                {
                    sum = sum - p[j].w + w;
                    del(j, p[j].v);
                    add(u, v, w);
                }
                printf("%d\n", sum);

            }
        }
    }
    return 0;
}
/*
10
4 10
1 2 1
2 3 3
1 3 1
3 4 1
2 3 3
2 3 0

5 6
1 2 5
2 3 1
2 4 4
2 5 3
1 2 3
1 4 1
*/

火碳黑 2011-03-21 09:36 发表评论

pku 3621 Sightseeing Cows——spfa判断负环

火碳黑 — Thu, 30 Sep 2010 13:53:00 GMT

Sightseeing Cows

Description

Farmer John has decided to reward his cows for their hard work by taking them on a tour of the big city! The cows must decide how best to spend their free time.

Fortunately, they have a detailed city map showing the L (2 ≤ L ≤ 1000) major landmarks (conveniently numbered 1.. L) and the P (2 ≤ P ≤ 5000) unidirectional cow paths that join them. Farmer John will drive the cows to a starting landmark of their choice, from which they will walk along the cow paths to a series of other landmarks, ending back at their starting landmark where Farmer John will pick them up and take them back to the farm. Because space in the city is at a premium, the cow paths are very narrow and so travel along each cow path is only allowed in one fixed direction.

While the cows may spend as much time as they like in the city, they do tend to get bored easily. Visiting each new landmark is fun, but walking between them takes time. The cows know the exact fun values F_i (1 ≤ F_i ≤ 1000) for each landmark i.

The cows also know about the cowpaths. Cowpath i connects landmark L_1i to L_2i (in the direction L_1i -> L_2i ) and requires time T_i (1 ≤ T_i ≤ 1000) to traverse.

In order to have the best possible day off, the cows want to maximize the average fun value per unit time of their trip. Of course, the landmarks are only fun the first time they are visited; the cows may pass through the landmark more than once, but they do not perceive its fun value again. Furthermore, Farmer John is making the cows visit at least two landmarks, so that they get some exercise during their day off.

Help the cows find the maximum fun value per unit time that they can achieve.

Input

* Line 1: Two space-separated integers: L and P
* Lines 2..L+1: Line i+1 contains a single one integer: F_i
* Lines L+2..L+P+1: Line L+i+1 describes cow path i with three space-separated integers: L_1i , L_2i , and T_i

Output

* Line 1: A single number given to two decimal places (do not perform explicit rounding), the maximum possible average fun per unit time, or 0 if the cows cannot plan any trip at all in accordance with the above rules.

Sample Input

Sample Output

6.00
题意：每点权val跟边权w，一条路径上的优乐值为点权和/边权和。求牛从一点出发到最后回到原点的最大优乐值
分析：二分参数ans，ans * w1 + ans * w2 + ... + ans * wi <= val1 + val2 + ... + vali;用spfa判断给出的ans能否构成
负环。有说明ans小了，没有说明ans大了。
代码：

#include <stdio.h>
#include <stdlib.h>
#include <queue>
#include <vector>
#define maxn 1005
#define inf 100000000
#define exp 0.00001
using namespace std;
int visit[maxn], val[maxn];
int cnt[maxn];
double dis[maxn];
struct T
{
    int v, w;
}e;
vector <T> g[maxn];
void set(int n)
{
    for (int i = 1; i <= n; i++)
    {
        g[i].clear();
    }
}
int spfa(int n, int s, double ans)
{
    int head = 0, tial = 1, i, u, v, w, size;
    double dd;
    queue<int> q;
    dis[s] = 0;
    cnt[s] = 1;
    q.push(s);
    while (!q.empty())
    {

        u = q.front();
        q.pop();
        visit[u] = 0;
        size = g[u].size();
        for (i = 0; i < size; i++)
        {
            v = g[u][i].v, w = g[u][i].w;
            dd = dis[u] + ans * w - val[v];
            if (dis[v] > dd)
            {
                dis[v] = dd;
                if (!visit[v])
                {
                    cnt[v]++;
                    if (cnt[v] > n)
                    {
                        return 0;
                    }
                    tial = (tial + 1) % maxn;
                    q.push(v);
                    visit[v] = 1;
                }
            }
        }
    }
    return 1;
}
int main()
{
    int n, m, i, u, v, w, th, sta;
    double l, r, mid;
    while (scanf("%d%d", &n, &m) != EOF)
    {
        set(n);
        for (i = 1, r = 0; i <= n; i++)
        {
            scanf("%d", &val[i]);
            r += val[i];
        }
        th = 0;
        T node;
        while (m--)
        {
            scanf("%d%d%d", &u, &v, &w);
            node.v = v, node.w = w;
            g[u].push_back(node);
        }
        l = 0;
        while (l + exp < r)
        {
            mid = (l + r) / 2.0;
            for (i = 1; i <= n; i++)
            {
                dis[i] = inf;
                visit[i] = 0;
                cnt[i] = 0;
            }
            sta = spfa(n, 1, mid);
            if (sta == 0)
            {
                l = mid + exp;
            }
            else
            {
                r = mid - exp;
            }
        }
        printf("%.2lf\n", l);
    }
    return 0;
}

火碳黑 2010-09-30 21:53 发表评论

pku 3613 Cow Relays ——经过n条路的最短路

火碳黑 — Thu, 30 Sep 2010 11:21:00 GMT

Cow Relays

Description

For their physical fitness program, N (2 ≤ N ≤ 1,000,000) cows have decided to run a relay race using the T (2 ≤ T ≤ 100) cow trails throughout the pasture.

Each trail connects two different intersections (1 ≤ I_1i ≤ 1,000; 1 ≤ I_2i ≤ 1,000), each of which is the termination for at least two trails. The cows know the length_i of each trail (1 ≤ length_i ≤ 1,000), the two intersections the trail connects, and they know that no two intersections are directly connected by two different trails. The trails form a structure known mathematically as a graph.

To run the relay, the N cows position themselves at various intersections (some intersections might have more than one cow). They must position themselves properly so that they can hand off the baton cow-by-cow and end up at the proper finishing place.

Write a program to help position the cows. Find the shortest path that connects the starting intersection (S) and the ending intersection (E) and traverses exactly N cow trails.

Input

* Line 1: Four space-separated integers: N, T, S, and E
* Lines 2..T+1: Line i+1 describes trail i with three space-separated integers: length_i , I_1i , and I_2i

Output

* Line 1: A single integer that is the shortest distance from intersection S to intersection E that traverses exactly N cow trails.

Sample Input

Sample Output

10
题意：求经过n条路的最短路。

#include <stdio.h>
#include <stdlib.h>
#define inf 1 << 30
#define maxn 101
#define Min(a, b) a < b ? a : b
int hash[maxn*10], g[maxn], num, ksp[23][maxn][maxn], len[maxn][2];
void set()
{
    int i;
    num = 0;
    for (i = 1; i < maxn; i++)
    {
        hash[i] = 0;
    }
}
int makeHash(int a)
{
    if (!hash[a])
    {
        hash[a] = ++num;
    }
    return hash[a];
}
int main()
{
    int n, t, s, e, h, i, j, k, u, v, w;
    while (scanf("%d%d%d%d", &n, &t, &s, &e) != EOF)
    {
        set();
        for (h = 0; h < 23; h++)
        {
            for (i = 1; i < maxn; i++)
            {
                for (j = 1; j < maxn; j++)
                {
                    ksp[h][i][j] = inf;
                }
            }
        }
        while (t--)
        {
            scanf("%d%d%d", &w, &u, &v);
            u = makeHash(u), v = makeHash(v);
            ksp[0][u][v] = ksp[0][v][u] = Min(w, ksp[0][v][u]);
        }
        s = makeHash(s), e = makeHash(e);
        for (h = 1; (1 << h) <= n; h++)//求出i到j经过2的h次方路径的最短路 
        {
            for (i = 1; i <= num; i++)
            {
                for (j = 1; j <= num; j++)
                {
                    if (ksp[h-1][i][j] < inf)
                    {
                        for(k = 1; k <= num; k++)
                        {
                            if (ksp[h][i][k] > ksp[h-1][i][j] + ksp[h-1][j][k])
                            {
                                ksp[h][i][k] = ksp[h-1][i][j] + ksp[h-1][j][k];
                            }
                            
                        }
                    }
                }
            }        
        }
        for (i = 1; i <= num; i++)
        {
            len[i][0] = inf;
        }
        len[s][0] = 0;
        for (h = 0, k = 0; (1 << h) <= n; h++)//组合s到其他节点经过n条路的最短路 
        {
            if (n & (1 << h))//枚举n的二进制上有1的。 
            {
                for (i = 1; i <= num; i++)
                {
                    len[i][k ^ 1] = inf;
                }
                for (i = 1; i <= num; i++)
                {
                    if (len[i][k] < inf)//这里要判断一下，因为1<<30再加上1<<30就超出int了 
                    {
                        for (j = 1; j <= num; j++)
                        {
                            len[j][k ^ 1] = Min(len[j][k ^1], len[i][k] + ksp[h][i][j]);
                        }
                    }
                }
                k = k ^ 1;
            }
        }
        printf("%d\n", len[e][k]);
    }
    system("pause");
    return 0;
}

火碳黑 2010-09-30 19:21 发表评论

pku 3013 Big Christmas Tree——最短路spfa

火碳黑 — Mon, 27 Sep 2010 12:39:00 GMT

Big Christmas Tree

Description

Christmas is coming to KCM city. Suby the loyal civilian in KCM city is preparing a big neat Christmas tree. The simple structure of the tree is shown in right picture.

The tree can be represented as a collection of numbered nodes and some edges. The nodes are numbered 1 through n. The root is always numbered 1. Every node in the tree has its weight. The weights can be different from each other. Also the shape of every available edge between two nodes is different, so the unit price of each edge is different. Because of a technical difficulty, price of an edge will be (sum of weights of all descendant nodes) × (unit price of the edge).

Suby wants to minimize the cost of whole tree among all possible choices. Also he wants to use all nodes because he wants a large tree. So he decided to ask you for helping solve this task by find the minimum cost.

Input

The input consists of T test cases. The number of test cases T is given in the first line of the input file. Each test case consists of several lines. Two numbers v, e (0 ≤ v, e ≤ 50000) are given in the first line of each test case. On the next line, v positive integers w_i indicating the weights of v nodes are given in one line. On the following e lines, each line contain three positive integers a, b, c indicating the edge which is able to connect two nodes a and b, and unit price c.

All numbers in input are less than 2¹⁶.

Output

For each test case, output an integer indicating the minimum possible cost for the tree in one line. If there is no way to build a Christmas tree, print “No Answer” in one line.

Sample Input

2
2 1
1 1
1 2 15
7 7
200 10 20 30 40 50 60
1 2 1
2 3 3
2 4 2
3 5 4
3 7 2
3 6 3
1 5 9

Sample Output

15
1210
题意：一个边在树中的代价是它的子树中所有节点权值的和乘以该边的权值。求连接所有点的最小代价。
分析：每个点到根贡献了路径的的权值和乘以改点权值。这就成了最短路的题了。
本来以为用个栈存点就行，没想到超时。
最后把它改为循环队列。

#include 
#include 
#define maxn 70001
#define Min(a, b) a < b ? a : b
long long inf = (long long)1 << 62;
struct
{
	int v, next, w;
}edge[maxn * 2];
int g[maxn], visit[maxn], stack[maxn * 2], val[maxn];
long long dis[maxn];
void set(int n)
{
	for (int i = 1; i <= n; i++)
	{
		g[i] = -1;
	}
}
void spfa(int n, int s)
{
	int i, u, w, v;
	for (i = 1; i <= n; i++)
	{
		dis[i] = inf, visit[i] = 0;
	}
	int top = 1, head = 0;
	stack[top] = s;
	dis[s] = 0;
	while (head != top)
	{
		head = (head + 1) % maxn;
		u = stack[head];
		visit[u] = 0;
		for (i = g[u]; i != -1; i = edge[i].next)
		{
			v = edge[i].v, w = edge[i].w;
			if (dis[v] > dis[u] + w)
			{
				dis[v] = dis[u] + w;
				if (!visit[v])
				{
					top = (top + 1) % maxn;
					stack[top] = v;
					visit[v] = 1;
				}
			}
		}
	}
	long long ans;
	for (i = 1, ans = 0; i <= n; i++)
	{
		if (dis[i] == inf)
		{
			break;
		}
		ans += dis[i] * val[i];
	}
	if (i != n + 1)
	{
		printf("No Answer\n");
	}
	else
	{
		printf("%lld\n", ans);
	}
}
int main()
{
	int t, n, m, i, th, u, v, w, min;
	scanf("%d", &t);
	while (t--)
	{

		scanf("%d%d", &n, &m);
		set(n);
		g[1] = -1;//处理点数为0时的初始化一个根，没初始化会超时 
		for (i = 1; i <= n; i++)
		{
			scanf("%d", &val[i]);
		}
		th = 0;
		while (m--)
		{
			scanf("%d%d%d", &u, &v, &w);
			edge[th].v = v, edge[th].w = w, edge[th].next = g[u], g[u] = th++;
			edge[th].v = u, edge[th].w = w, edge[th].next = g[v], g[v] = th++;	
		}
		spfa(n, 1);
	}
	system("pause");
	return 0;
}

火碳黑 2010-09-27 20:39 发表评论