C++博客-夜幻梦回-文章分类-图论

树的最长路径L —— 具有:所有除了L上的点的叶子点到L的距离最长这最小

火碳黑 — Sun, 10 Apr 2011 02:02:00 GMT

Highway Construction

Description

As head of the Accessible Commuting Movement (ACM), you've been lobbying the mayor to build a new highway in your city. Today is your lucky day, because your request was approved. There is one condition though: You must provide the plan for the best highway artery to construct, or else it's not going to happen! You have a map that shows all communities in your city, each with a unique number, where you may place highway on-ramps. On the map are a set of roadways between pairs of communities, labelled with driving distances, which you may choose to replace with your highway line. Using this network of roadways, there is exactly one route from any one community to another. In other words, there are no two dierent sets of roadways that would lead you from community A to community B.

You can build a single highway that runs back and forth between any two communities of your choosing.

It will replace the unique set of roadways between those two communities, and an on-ramp will be built at every community along the way. Of course, residents of communities that will not have an on-ramp will have to drive to the nearest one that does in order to access your new highway.

You know that long commutes are very undesirable, so you are going to build the highway so that longest drive from any community to the nearest on-ramp is minimized. Given a map of your city with the roadways and driving distances, what is the farthest distance from any community that someone would have to drive to get to the nearest on-ramp once your new highway is complete?

Input

The input consists of multiple test cases. Each test case is a description of a city map, and begins with a single line containing an integer N (2 ≤ N ≤ 100,000), the number of communities in the city. Then N -1 lines follow, each containing three integers, i, j (1 ≤ i, j ≤ N ), and d (1 ≤ d ≤ 10,000).

Each line indicates that communities i and j are connected by a roadway with driving distance d. Input is followed by a single line with N = 0, which should not be processed.

Output

For each city map, output on a single line the farthest distance from any community to the nearest on-ramp of the new highway.

Sample Input

Sample Output

题意:给出一棵树，每个树边有权值。求一条树干，使得所有叶子节点到这个树干的距离最小。（树干是连个叶子节点之间的一条线）；
分析：假设树的直径L是这条树干S。
证明：反证L不是这个S
那分为两种情况：
1.这个L跟S有交集。交集的两个端点分别为A，B。将AB切断，设L的端点跟A同一侧的为la，S的端点跟A同一侧为sa，则la到A的距离比sa到A的距离更小。因为L中la到A的这段可以被sa到A的这段取代。
这与L是直径构成矛盾。
2.L跟S没交集。设p为L中的一个点，q为S中的一个点。由于是一棵树，我们一定可以找某个p到某个s的一条路径使得L跟S被连通，而且这个路径只有一条。则存在S的一个端点sa到q的距离比L的一个端点la到q的距离（即la到p的路径长度+p到q的路径长度）更长。这与L是直径矛盾，因为L中从p到la那一段可以被p到q再到sa的那一段取代。
反证不成立，假设勉强YY成立。
下面是代码，比较丑陋。因为敲时没能百分百确定能以上结论成立。所以是写的时候比较随意。都是AC了才敢妄下这种YY的证明。
接下来是树的直径求法证明，网上贴的。

树的直径(Diameter)是指树上的最长简单路。
直径的求法：两遍BFS (or DFS)
任选一点u为起点，对树进行BFS遍历，找出离u最远的点v
以v为起点，再进行BFS遍历，找出离v最远的点w。则v到w的路径长度即为树的直径
*简单证明
于是原问题可以在O(E)时间内求出
关键在于证明第一次遍历的正确性，也就是对于任意点u，距离它最远的点v一定是最长路的一端。
如果u在最长路上，那么v一定是最长路的一端。可以用反证法：假设v不是最长路的一端，则存在另一点v’使得(u→v’)是最长路的一部分，于是len(u→v’) > len(u→v)。但这与条件“v是距u最远的点”矛盾。
如果u不在最长路上，则u到其距最远点v的路与最长路一定有一交点c，且(c→v)与最长路的后半段重合，即v一定是最长路的一端
这里自己补充下：设树直径的一点c最先被搜到，设以C为根的子树为Tc则C到树直径的两个端点的距离的最长者X都长于C到任意其他点的距离。包括u到C之间的所有子树（T-tc）的所有点到C的距离y也比X小。所以u为0距离开始搜索后点v跟u最远的肯定是树的一个端点。也是比较yy。

#include <stdio.h>
#include <stdlib.h>
#define Max(a, b) a > b ? a : b
#define Min(a, b) a < b ? a : b
#define maxn 110000
struct T
{
    int v, w, next;
}fn[maxn * 2];
int n, th;
int dis[maxn], g[maxn], visit[maxn], path[maxn];
void setGraph()
{
    th = 0;
    for (int i = 0; i <= 2 * n; i++)
    {
        g[i] = -1;
    }
}
void add(int u, int v, int w)
{
    fn[th].v = v, fn[th].w = w, fn[th].next = g[u], g[u] = th++;
    fn[th].v = u, fn[th].w = w, fn[th].next = g[v], g[v] = th++;
}
void dfs(int u)
{
    visit[u] = 1;
    int i;
    for (i = g[u]; i != -1; i = fn[i].next)
    {
        if (!visit[fn[i].v])
        {
            path[fn[i].v] = u;
            dis[fn[i].v] = dis[u] + fn[i].w;
            dfs(fn[i].v);
        }
    }
}
void find(int u, int f)
{
    visit[u] = 1;
    int i, v;
    for (i = g[u]; i != -1; i = fn[i].next)
    {
        v = fn[i].v;
        if (v != f && visit[v] == 0)
        {
            dis[v] = dis[u] + fn[i].w;
            dfs(v);
        }
    }
}
int main()
{
    int i, u, v, w, min, j;
    while (scanf("%d", &n) , n)
    {
        setGraph();
        for (i = 1; i < n; i++)
        {
            scanf("%d%d%d", &u, &v, &w);
            add(u, v, w);
        }
        for (i = 1; i <= n; i++)
        {
            visit[i] = 0;
        }
        dis[1] = 0;
        dfs(1);//第一次dfs找树直径的一个端点，这个的path没用的。
        for (i = 1, min = -1; i <= n; i++)
        {
            if (min < dis[i])
            {
                min = dis[i];
                j = i;
            }
        }
        for (i = 1; i <= n; i++)
        {
            visit[i] = 0;
        }
        dis[j] = 0;
        path[j] = -1;
        dfs(j);//通过端点找另一个端点，并保存路径。
        for (i = 1, min = -1; i <= n; i++)
        {
            if (min < dis[i])
            {
                min = dis[i];
                j = i;
            }
        }
        for (i = 1; i <= n; i++) visit[i] = 0;
        for (i = j; i != -1; i = path[i])//从直径上搜索计算每个叶子到直径的距离
        {
            dis[i] = 0;
            find(i, path[i]);
        }
        for (i = 1, min = -1; i <= n; i++)
        {
            if (min < dis[i])
            {
                min = dis[i];
            }
        }
        printf("%d\n", min);
    }
    return 0;
}

火碳黑 2011-04-10 10:02 发表评论

poj 2987——最大闭权图运用最大流dinic

火碳黑 — Sat, 09 Apr 2011 05:44:00 GMT

Firing

Description

You’ve finally got mad at “the world’s most stupid” employees of yours and decided to do some firings. You’re now simply too mad to give response to questions like “Don’t you think it is an even more stupid decision to have signed them?”, yet calm enough to consider the potential profit and loss from firing a good portion of them. While getting rid of an employee will save your wage and bonus expenditure on him, termination of a contract before expiration costs you funds for compensation. If you fire an employee, you also fire all his underlings and the underlings of his underlings and those underlings’ underlings’ underlings… An employee may serve in several departments and his (direct or indirect) underlings in one department may be his boss in another department. Is your firing plan ready now?

Input

The input starts with two integers n (0 < n ≤ 5000) and m (0 ≤ m ≤ 60000) on the same line. Next follows n + m lines. The first n lines of these give the net profit/loss from firing the i-th employee individually b_i (|b_i| ≤ 10⁷, 1 ≤ i ≤ n). The remaining m lines each contain two integers i and j (1 ≤ i, j ≤ n) meaning the i-th employee has the j-th employee as his direct underling.

Output

Output two integers separated by a single space: the minimum number of employees to fire to achieve the maximum profit, and the maximum profit.

Sample Input

Sample Output

2 2

Hint

As of the situation described by the sample input, firing employees 4 and 5 will produce a net profit of 2, which is maximum.

题意：
公司要裁员，裁掉一个员工，他的下属也得裁掉。裁掉一个员工可以少发一定的工资，但他已经他的下属全被裁掉，所以这个partment会减少一定的生产利润。显然，裁掉一个人就可能得到收益（正的或者负的）；
给出裁掉一个员工能获得的收益（正或负）。
给出公司里员工的依赖关系。表示A有下属B
问得到的最大利益以及裁掉的最少人数。
分析：在这些人中选若干人，使得收益最大。如果A有下属B，那我裁掉A就得裁掉B。所以裁掉B成了裁掉A的必要条件，即A依赖于B。所以让A连向B，A->B容量为正无穷。
那么选若干人事效益最大就是求这个权闭合图的最大值。
之后对于收益是正的人，s->x容量为收益值，对于收益是负的人x->t，容量为收益值得绝对值。
结果就是正权值和-最小割值（最大流：图中切割最小的值）=最大权闭合图的值。
这个图从s出发的边都是收益，从x->t的边都是消耗。那求最小割就是对于给出的这么多的收益，通过多少消耗能让取得的收益最大。
那最后的利润就是：总利润和-取得利润最大所需的消耗。

#include <iostream>
#include <stdlib.h>
using namespace std;
const int maxn= 20010;
const __int64 inf=0x7fffffff;
struct node
{
    __int64 v,next;
    __int64 w;
}fn[500010];
__int64 level[maxn],g[maxn],que[maxn],out[maxn],th, tip, visit[maxn];
inline void add(__int64 u,__int64 v,__int64 w)
{
    fn[th].v = v, fn[th].w = w, fn[th].next = g[u], g[u] = th++;
    fn[th].v = u, fn[th].w = 0, fn[th].next = g[v], g[v] = th++;
}
void build_level(__int64  n,__int64 s,__int64  e)
{
    __int64 h=0,r=0,i,u;
    for (i = 0; i <= n; i++) level[i]=0;
    level[s] = 1;
    que[0] = s;
    while(h <= r)
    {
        u = que[h++];
        for (i = g[u]; i != -1; i = fn[i].next)
        {
            if (fn[i].w && level[fn[i].v] == 0)
            {
                que[++r] = fn[i].v;
                level[fn[i].v] = level[u] + 1;
             }
        }
    }
}
__int64 dinic(__int64 n,__int64 s,__int64 e)
{
    __int64 ret=0,i;
    while(1)
    {
        build_level(n,s,e);
        if (level[e] == 0) break;
        for (i = 0; i < n; ++i) out[i] = g[i];
        __int64 q = -1;
        while(1)
        {
            if (q < 0)
            {
                for (i = out[s]; i != -1; i = fn[i].next)
                {
                    if (fn[i].w && out[fn[i].v] != -1 && level[fn[i].v] == 2)
                    {
                        que[++q] = i;
                        out[s] = fn[i].next;
                        break;
                    }
                }
                if (i == -1)
                {
                    break;
                }
            }
            __int64 u = fn[que[q]].v;
            if(u == e)
            {
                __int64 tmp=inf;
                for(i = 0;i <= q; i++)
                    if(tmp > fn[que[i]].w)tmp = fn[que[i]].w;
                ret += tmp;
                for(i=0;i<=q;i++)
                {
                    fn[que[i]].w -= tmp;
                    fn[que[i]^1].w += tmp;
                }
                for (i = 0; i <= q; i++)
                {
                    if(fn[que[i]].w == 0)
                    {
                        q = i-1;
                        break;
                    }
                }
            }
            else
            {
                for (i = out[u]; i != -1; i = fn[i].next)
                {
                    if (fn[i].w && out[fn[i].v] !=-1 && level[u] + 1 == level[fn[i].v])
                    {
                        que[++q] = i, out[u] = fn[i].next;
                        break;
                    }
                }
                if(i==-1)
                {
                    out[u] = -1, q--;
                 }

            }
        }
    }
    return ret;
}
void dfs(int s, int e)
{
    int i;
    if (s == e)
    {
        return;
    }
    for (i = g[s]; i != -1; i++)
    {
        if (!visit[fn[i].v] && fn[i].w)
        {
            dfs(fn[i].v, e);
        }
    }
}
int main()
{
    __int64 m, n, t, u, v, i, j, start, end, sum, num, w, ans;
    int k = 0;
    while (scanf("%I64d%I64d", &n, &m) - EOF)
    {
        k++;
        start = 0, end = n + 1, th = 0;
        for (i = 0; i <= end; i++)
        {
            g[i] = -1;
        }
        for (i = 1, sum = 0; i <= n; i++)
        {
            scanf("%I64d", &num);
            if (num >= 0)
            {
                add(start, i, num);
                sum += num;
            }
            else
            {
                add(i, end, -num);
            }
        }
        for (j = 1; j <= m; j++)
        {
            scanf("%I64d%I64d", &u, &v);
            add(u, v, inf);
        }
        sum -= dinic(end + 1, start, end);
        tip = 0;
        for (i = 0; i <= end + 1; i++)
        {
            visit[i] = 0;
        }
        dfs(0, end);
        for (i = 0, tip = 0; i <= end + 1; i++)
        {
            if (visit[i])
            {
                tip++;
            }
        }
        printf("%I64d %I64d\n", tip, ans);
    }
    //system("pause");
    return 0;
}

火碳黑 2011-04-09 13:44 发表评论

pku 1486 Sorting Slides ——二分图最大匹配

火碳黑 — Wed, 30 Mar 2011 13:40:00 GMT

Sorting Slides

Description

Professor Clumsey is going to give an important talk this afternoon. Unfortunately, he is not a very tidy person and has put all his transparencies on one big heap. Before giving the talk, he has to sort the slides. Being a kind of minimalist, he wants to do this with the minimum amount of work possible.

The situation is like this. The slides all have numbers written on them according to their order in the talk. Since the slides lie on each other and are transparent, one cannot see on which slide each number is written.

Well, one cannot see on which slide a number is written, but one may deduce which numbers are written on which slides. If we label the slides which characters A, B, C, ... as in the figure above, it is obvious that D has number 3, B has number 1, C number 2 and A number 4.

Your task, should you choose to accept it, is to write a program that automates this process.

Input

The input consists of several heap descriptions. Each heap descriptions starts with a line containing a single integer n, the number of slides in the heap. The following n lines contain four integers xmin, xmax, ymin and ymax, each, the bounding coordinates of the slides. The slides will be labeled as A, B, C, ... in the order of the input.

This is followed by n lines containing two integers each, the x- and y-coordinates of the n numbers printed on the slides. The first coordinate pair will be for number 1, the next pair for 2, etc. No number will lie on a slide boundary.

The input is terminated by a heap description starting with n = 0, which should not be processed.

Output

For each heap description in the input first output its number. Then print a series of all the slides whose numbers can be uniquely determined from the input. Order the pairs by their letter identifier.

If no matchings can be determined from the input, just print the word none on a line by itself.

Output a blank line after each test case.

Sample Input

Sample Output

				Heap 1
(A,4) (B,1) (C,2) (D,3)

Heap 2
none
题意：有编号的幻灯片是透明的，叠在一起的时候，除了没被覆盖的编号，其他的编号被多张幻灯片覆盖时就分不清哪个编号是哪张的。
但能通过确定的幻灯片的编号（编号只被一张幻灯片覆盖，这个编号就是该幻灯片的）来用排除法确定其他幻灯片的编号。
求：是否能确定所有幻灯片的编号。如果可以，对每张幻灯片，判断这个编号是否是唯一的。对唯一编号幻灯片输出编号。
分析：这个直接是比较明显的二分图最大匹配。首先肯定是选取唯一确定的幻灯片不用，接下来就是交叉路径求可增光路的事了。整个过程就是匈牙利算法。
求出匹配方案M，对M中每次删除一个边，再次通过该边的一点看看是否有可增光路，有则会再次达到最大匹配，这说明该编号对应的可选矩形不唯一。

#include <iostream>
#define maxn 1000
using namespace std;
struct T
{
    int x1, x2, y1, y2;
}reg[maxn];
int mat[maxn][maxn], hash[maxn], pre[maxn], path[maxn];
int n;
int more(int u)
{
    int i;
    for (i = 0; i < n; i++)
    {
        if (hash[i] == 0 && mat[u][i])
        {
            hash[i] = 1;
            if (pre[i] == -1 || more(pre[i]))
            {
                pre[i] = u;
                return 1;
            }
        }
    }
    return 0;
}
int eft()
{
    int i, j, num;
    for (i = 0; i < n; i++) pre[i] = -1;
    for (i = 0, num = 0; i < n; i++)
    {
        for (j = 0; j < n; j++) hash[j] = 0;
        if (more(i))
        {
            num++;
        }
    }
    return num;
}
int main()
{
    int i, j, x1, x2, y1, y2, x, y, num, sign, ca = 0, m;
    while (scanf("%d", &n), n)
    {
        ca++;
        for (i = 0; i < n; i++)
        {
            scanf("%d%d%d%d", &reg[i].x1, &reg[i].x2, &reg[i].y1, &reg[i].y2);
        }
        for (i = 0; i < n; i++)
        {
            scanf("%d%d", &x, &y);
            for (j = 0; j < n; j++)//编号被幻灯片上覆盖的，编号跟其连边，表示该编号可能在该幻灯片上
            {
                if (x > reg[j].x1 && x < reg[j].x2 && y > reg[j].y1 && y < reg[j].y2)
                {
                    mat[i][j] = 1;
                }
                else
                {
                    mat[i][j] = 0;
                }
            }
        }
        num = eft();
        sign = 0;
        printf("Heap %d\n", ca);
        if (num == n)//能找到一种方案让每个编号对应一个幻灯片
        {
            for (i = 0; i < n; i++)
            {
                path[i] = pre[i];
            }
            for (i = 0; i < n; i++)
            {
                mat[path[i]][i] = 0;//删边
                if (eft() == num)//如果能再次达到最大匹配M，则编号跟幻灯片不是唯一的
                {
                    continue;
                }
                else
                {                    
                    if (sign)
                    {
                        printf(" ");
                    }
                    printf("(%c,%d)", 'A' + i, path[i] + 1);//否则，输出唯一对应的幻灯片跟编号。
                    sign = 1;
                }
                mat[path[i]][i] = 1;
            }
        }    
        if (!sign)
        {
            printf("none");
        }
        printf("\n\n");
    }
    return 0;
}

火碳黑 2011-03-30 21:40 发表评论

本校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 发表评论

pku 3207 Ikki's Story IV - Panda's Trick——2-sat判定性问题

火碳黑 — Mon, 27 Sep 2010 08:19:00 GMT

Ikki's Story IV - Panda's Trick

Description

liympanda, one of Ikki’s friend, likes playing games with Ikki. Today after minesweeping with Ikki and winning so many times, he is tired of such easy games and wants to play another game with Ikki.

liympanda has a magic circle and he puts it on a plane, there are n points on its boundary in circular border: 0, 1, 2, …, n − 1. Evil panda claims that he is connecting m pairs of points. To connect two points, liympanda either places the link entirely inside the circle or entirely outside the circle. Now liympanda tells Ikki no two links touch inside/outside the circle, except on the boundary. He wants Ikki to figure out whether this is possible…

Despaired at the minesweeping game just played, Ikki is totally at a loss, so he decides to write a program to help him.

Input

The input contains exactly one test case.

In the test case there will be a line consisting of of two integers: n and m (n ≤ 1,000, m ≤ 500). The following m lines each contain two integers a_i and b_i, which denote the endpoints of the ith wire. Every point will have at most one link.

Output

Output a line, either “panda is telling the truth...” or “the evil panda is lying again”.

Sample Input

4 2
0 1
3 2

Sample Output

panda is telling the truth...
题意:给出n个构成一个环的点以及点跟点的连接关系。要求边不能相交。比如：有一条边i会跟j看成直线的话在园内相交，那么可以
把一条通过边弯绕过圆，使得两条边不相交。最后问是否所有线段都不相交。
分析：对于两条边，如果在园内相交，则必须引导一条通过园外。把边i看成点i1和i2分别表示通过园内和园外。
如果i与j相交于园内，则i1->j2，i2->j1, j2->i1, j1->i2.表示两条边一条在园外，一条在园内。通过求scc确定每条边的i1和i2
所在的scc是否相同，相同表示i既是在园内也是在园外，矛盾了。
代码：

#include <stdio.h>
#include <stdlib.h>
#define Min(a, b) a < b ? a : b
#define maxn 5010
struct L
{
    int x, y;
}line[500000];
struct g
{
    int v, next;
}fn[maxn * 4];
int g[maxn * 5], visit[maxn * 5], low[maxn * 5];
void set(int m)
{
    for (int i = 1; i <= m; i++)
    {
        g[i] = -1, visit[i] = 0;
    }
}
int tarjan(int u, int f, int times)
{
    low[u] = times;
    visit[u] = 1;
    int i, v;
    for (i = g[u]; i != -1; i = fn[i].next)
    {
        v = fn[i].v;
        if (v != f)
        {
            if (!visit[v])
            {
                times = tarjan(v, u, times + 1);
            }
            low[u] = Min(low[u], low[v]);
        }
    }
    return times;
}
int main()
{
    int n, m, i, j, th, times;
    scanf("%d%d", &n, &m);
        set(m * 2);
        for (i = 1; i <= m; i++)
        {
            scanf("%d%d", &line[i].x, &line[i].y);
            if (line[i].x > line[i].y)
            {
                line[i].x ^= line[i].y, line[i].y ^= line[i].x, line[i].x ^= line[i].y;
            }
        }
        for (i = 1, th = 0; i < m; i++)
        {
            for (j = i + 1; j <= m; j++)
            {
                //对相交的线段建图 
                if (line[i].x < line[j].y && line[i].x > line[j].x && line[i].y > line[j].y
                    || line[i].y < line[j].y && line[i].y > line[j].x && line[i].x < line[j].x)
                {
                    //printf("%d %d %d %d\n", line[i].x, line[i].y, line[j].x, line[j].y);
                    fn[th].v = j + m, fn[th].next = g[i], g[i] = th++;
                    fn[th].v = i, fn[th].next = g[j+m], g[j+m] = th++;
                    fn[th].v = j, fn[th].next = g[i+m], g[i+m] = th++;
                    fn[th].v = i + m, fn[th].next = g[j], g[j] = th++;
                }
            }
        }//system("pause");
        for (i = 1, times = 1; i <= 2 * m; i++)
        {
            if (!visit[i])
            {
                times = tarjan(i, -1, times + 1);
            }
            //printf("[%d]=%d ", i, low[i]);
        }//printf("\n");
        for (i = 1; i <= m; i++)
        {
            if (low[i] == low[i+m])
            {
                break;
            }
        }
        if (i == m + 1)
        {
            printf("panda is telling the truth\n");
        }
        else
        {
            printf("the evil panda is lying again\n");
        }
    system("pause");
    return 0;
}
/*
10 3
1 5
2 6
7 3
*/

火碳黑 2010-09-27 16:19 发表评论

pku 3177 Redundant Paths——无向图双连通分量缩点

火碳黑 — Sun, 26 Sep 2010 12:25:00 GMT

Redundant Paths

Description

In order to get from one of the F (1 <= F <= 5,000) grazing fields (which are numbered 1..F) to another field, Bessie and the rest of the herd are forced to cross near the Tree of Rotten Apples. The cows are now tired of often being forced to take a particular path and want to build some new paths so that they will always have a choice of at least two separate routes between any pair of fields. They currently have at least one route between each pair of fields and want to have at least two. Of course, they can only travel on Official Paths when they move from one field to another.

Given a description of the current set of R (F-1 <= R <= 10,000) paths that each connect exactly two different fields, determine the minimum number of new paths (each of which connects exactly two fields) that must be built so that there are at least two separate routes between any pair of fields. Routes are considered separate if they use none of the same paths, even if they visit the same intermediate field along the way.

There might already be more than one paths between the same pair of fields, and you may also build a new path that connects the same fields as some other path.

Input

Line 1: Two space-separated integers: F and R

Lines 2..R+1: Each line contains two space-separated integers which are the fields at the endpoints of some path.

Output

Line 1: A single integer that is the number of new paths that must be built.

Sample Input

Sample Output

				2

题意：给出一个连通图，求至少添加多少条边，使得对于任意两点，不只一条路。即两点间的路去掉一条边还是连通的。

#include <stdio.h>
#include <stdlib.h>
#define Min(a, b) a < b ? a : b
#define maxn 5001
struct T
{
    int v, next;
}fn[maxn * 4];
int g[maxn], indegree[maxn], visit[maxn], low[maxn];
void set(int n)
{
    for (int i = 1; i <= n; i++)
    {
        g[i] = -1;
        indegree[i] = 0;
        visit[i] = 0;
    }    
}
int tarjan(int u, int f, int time)
{
    int i, v;
    visit[u] = 1;
    low[u] = time;
    for (i = g[u]; i != -1; i = fn[i].next)
    {
        v = fn[i].v;
        if (v != f)
        {
            if(!visit[v])
            {
                time = tarjan(v, u, time + 1);
            }
            low[u] = Min(low[u], low[v]);
        }
    }
    return time;
}
int isok(int u, int v)
{
    int i;
    for (i = g[u]; i != -1; i = fn[i].next)
    {
        if (fn[i].v == v)
        {
            //printf("ooo\n");
            return 0;
        }
    }
    return 1;
}
int main()
{
    int n, m, u, v, th, sum, i, j;
    while (scanf("%d%d", &n, &m) != EOF)
    {
        th = 0;
        set(n);
        while (m--)
        {
            scanf("%d%d", &u, &v);
            if (isok(u,v))//处理重边，重边在求双连通分量时没影响，但在统计度时，由于重边也要重建，所以度会变多 
            {
                fn[th].v = v, fn[th].next = g[u], g[u] = th++;
                fn[th].v = u, fn[th].next = g[v], g[v] = th++;
            }
        }
        tarjan(1, -1, 1);
        for (i = 1; i <= n; i++)
        {
            for (j = g[i]; j != -1; j = fn[j].next)
            {
                if (low[i] != low[fn[j].v])
                {
                    indegree[low[i]]++;
                }
            }
        }
        for (i = 1, sum = 0; i <= n; i++)
        {
            if (indegree[i] == 1)
            {
                sum++;
            }
        }
        printf("%d\n", (sum + 1) / 2);
    }
    //system("pause");
    return 0;
}
/*
首先这道题有重边，如
2 2
1 2
1 2
应该输出 1
2 2
1 2
2 1
*/

火碳黑 2010-09-26 20:25 发表评论

pku 3352 Road Construction——无向图强连通分量

火碳黑 — Fri, 17 Sep 2010 05:20:00 GMT

Road Construction

Description

It's almost summer time, and that means that it's almost summer construction time! This year, the good people who are in charge of the roads on the tropical island paradise of Remote Island would like to repair and upgrade the various roads that lead between the various tourist attractions on the island.

The roads themselves are also rather interesting. Due to the strange customs of the island, the roads are arranged so that they never meet at intersections, but rather pass over or under each other using bridges and tunnels. In this way, each road runs between two specific tourist attractions, so that the tourists do not become irreparably lost.

Unfortunately, given the nature of the repairs and upgrades needed on each road, when the construction company works on a particular road, it is unusable in either direction. This could cause a problem if it becomes impossible to travel between two tourist attractions, even if the construction company works on only one road at any particular time.

So, the Road Department of Remote Island has decided to call upon your consulting services to help remedy this problem. It has been decided that new roads will have to be built between the various attractions in such a way that in the final configuration, if any one road is undergoing construction, it would still be possible to travel between any two tourist attractions using the remaining roads. Your task is to find the minimum number of new roads necessary.

Input

The first line of input will consist of positive integers n and r, separated by a space, where 3 ≤ n ≤ 1000 is the number of tourist attractions on the island, and 2 ≤ r ≤ 1000 is the number of roads. The tourist attractions are conveniently labelled from 1 to n. Each of the following r lines will consist of two integers, v and w, separated by a space, indicating that a road exists between the attractions labelled v and w. Note that you may travel in either direction down each road, and any pair of tourist attractions will have at most one road directly between them. Also, you are assured that in the current configuration, it is possible to travel between any two tourist attractions.

Output

One line, consisting of an integer, which gives the minimum number of roads that we need to add.

Sample Input

Sample Output

2
0
题意：给出一个连通图，求至少添加几条边，使得图去掉任意一条边，还是连通的。
强连通分量缩点生成一颗树，求入度为1的连通分量个数n，结果为(n+1)/2；
无向图不用像有向图那样考虑是否该点在栈中，因为u跟v只要有边，说明u一定可以到到达v，v可以到达u；
而有向图，比如1->2, 3->2,假如从1搜索到2，1跟2属于两个独立的强连通分量，而从3搜到2，发现2被搜过，但2不在栈里，所以
不能使low[3] = low[2];所以无向图的tarjan比有向图的简单了很多。

代码：

#include <stdio.h>
#include <stdlib.h>
#define Min(a, b) a < b ? a : b
#define Max(a, b) a > b ? a : b
#define maxn 1001
struct edge
{
    int v, next;
}fn[maxn * maxn];
int visit[maxn], g[maxn], du[maxn],  low[maxn];
void set(int n)
{
    for (int i = 1; i <= n; i++)
    {
        visit[i] = 0, g[i] = -1, du[i] = 0;
    }
}
int tarjan(int f, int u, int times)
{
    visit[u] = 1;
    low[u] = times;
    int i, v;
    for (i = g[u]; i != -1; i = fn[i].next)
    {
        v = fn[i].v;
        if (v != f)
        {
            if (!visit[v])
            {
                times = tarjan(u, v, times + 1);
                low[u] = Min(low[u], low[v]);
            }
            low[u] = Min(low[u], low[v]);
        }
    }
    return times;
}
int main()
{
    char a[10], b[10];
    int ca, n, m, th, u, v, i, times, top, k, j;
    while (scanf("%d%d", &n, &m) != EOF)
    {
        set(n);
        th = 0;
        while (m--)
        {
            scanf("%d%d", &u, &v);
            fn[th].v = v, fn[th].next = g[u], g[u] = th++;
            fn[th].v = u, fn[th].next = g[v], g[v] = th++;
        }
        for (i = 1, times = 0; i <= n; i++)
        {
            if (!visit[i])
            {
                times = tarjan(-1, i, times + 1); 
            }
        }
        for (i = 1; i <= n; i++)
        {
            for (j = g[i]; j != -1; j = fn[j].next)
            {
                if (low[i] != low[fn[j].v])
                {
                    du[low[i]]++;
                }
            }
        }
        for (i = 1, k = 0; i <= n; i++)
        {
            if (du[i] == 1)
            {
                k++;
            }
        }
        printf("%d\n", (k + 1) / 2);
    }
    system("pause");
    return 0;
}

代码2：

#include <stdio.h>
#include <stdlib.h>
#define Min(a, b) a < b ? a : b
#define Max(a, b) a > b ? a : b
#define maxn 1001
struct edge
{
    int v, next;
}fn[maxn * maxn];
int visit[maxn], scc[maxn], g[maxn], du[maxn], stack[maxn], dfn[maxn], low[maxn], top, num, hash[maxn];
void set(int n)
{
    for (int i = 1; i <= n; i++)
    {
        visit[i] = 0, scc[i] = -1, g[i] = -1, du[i] = 0, hash[i] = 0;
    }
}
int tarjan(int f, int u, int times)
{
    visit[u] = 1;
    stack[top++] = u;
    dfn[u] = low[u] = times;
    int i, v;
    for (i = g[u]; i != -1; i = fn[i].next)
    {
        v = fn[i].v;
        if (v != f)
        {
            if (!visit[v])
            {
                times = tarjan(u, v, times + 1);
                low[u] = Min(low[u], low[v]);
            }
            else if (scc[v] == -1)
            {
                low[u] = Min(low[u], low[v]);
            }
        }
    }
    if (low[u] == dfn[u])
    {
        num++;
        do
        {
            scc[stack[--top]] = num;
            //printf("%d ", stack[top]);
        }while (stack[top] != u);//printf("-=-=\n");
    }
    return times;
}
int main()
{
    char a[10], b[10];
    int ca, n, m, th, u, v, i, times, top, k, j;
    scanf("%d%d", &n, &m);
        set(n);
        th = 0;
        while (m--)
        {
            scanf("%d%d", &u, &v);
            fn[th].v = v, fn[th].next = g[u], g[u] = th++;
            fn[th].v = u, fn[th].next = g[v], g[v] = th++;
        }
        for (i = 1, times = 0, top = 0, num = 0; i <= n; i++)
        {
            if (!visit[i])
            {
                times = tarjan(-1, i, times); 
            }
        }
        for (i = 1; i <= n; i++)
        {
            hash[i] = 1;
            for (j = g[i]; j != -1; j = fn[j].next)
            {
                if (scc[i] != scc[fn[j].v])
                {
                    du[scc[i]]++;
                }
            }
        }
        for (i = 1, k = 0; i <= num; i++)
        {
            //printf("[%d] = %d ", i, du[i]);
            if (du[i] == 1)
            {
                k++;
            }
        }
        printf("%d\n", (k + 1) / 2);
    return 0;
}

火碳黑 2010-09-17 13:20 发表评论

pku 1236 Network of Schools——强连通分量缩点求入度分量为0个数和出度为0的分量个数

火碳黑 — Thu, 16 Sep 2010 03:05:00 GMT

Network of Schools

Description

A number of schools are connected to a computer network. Agreements have been developed among those schools: each school maintains a list of schools to which it distributes software (the “receiving schools”). Note that if B is in the distribution list of school A, then A does not necessarily appear in the list of school B
You are to write a program that computes the minimal number of schools that must receive a copy of the new software in order for the software to reach all schools in the network according to the agreement (Subtask A). As a further task, we want to ensure that by sending the copy of new software to an arbitrary school, this software will reach all schools in the network. To achieve this goal we may have to extend the lists of receivers by new members. Compute the minimal number of extensions that have to be made so that whatever school we send the new software to, it will reach all other schools (Subtask B). One extension means introducing one new member into the list of receivers of one school.

Input

The first line contains an integer N: the number of schools in the network (2 <= N <= 100). The schools are identified by the first N positive integers. Each of the next N lines describes a list of receivers. The line i+1 contains the identifiers of the receivers of school i. Each list ends with a 0. An empty list contains a 0 alone in the line.

Output

Your program should write two lines to the standard output. The first line should contain one positive integer: the solution of subtask A. The second line should contain the solution of subtask B.

Sample Input

Sample Output

1
2
题意：1.要求出至少发分配多少站点，使所有点都能收到，即求入度为0的分量。
      2.求要添加多少点，使任意一个点发送物品，其他点都能收到物品，即求Max(入度为0的分量个数,出度为0的分量个数)。
代码：

#include <stdio.h>
#include <stdlib.h>
#define Min(a, b) a < b ? a : b
#define Max(a, b) a > b ? a : b
#define maxn 101
struct node
{
    int v, next;
}fn[maxn * maxn];
int g[maxn], visit[maxn], dfn[maxn], low[maxn], scc[maxn], stack[maxn], top, num, flag1[maxn], flag2[maxn];
void set(int n)
{
    for (int i = 1; i <= n; i++)
    {
        g[i] = -1, scc[i] = -1, visit[i] = 0, flag1[i] = 0 ,flag2[i] = 0;
    }
}
int tarjan(int u, int times)
{
    low[u] = dfn[u] = times;
    visit[u] = 1;
    stack[top++] = u;
    int i, v;
    for (i = g[u]; i != -1; i = fn[i].next)
    {
        v = fn[i].v;
        if (!visit[v])
        {
            times = tarjan(v, times + 1);
            low[u] = Min(low[u], low[v]);
        }
        else if (scc[v] == -1)
        {
            low[u] = Min(low[u], low[v]);
        }
    }
    if (low[u] == dfn[u])
    {
        num++;
        do
        {
            scc[stack[--top]] = num;
        }while (stack[top] != u);
    }
    return times;
}
void circle(int n)
{
    int times = 0, i;
    top = 0, num = 0;
    for (i = 1; i <= n; i++)
    {
        if (!visit[i])
        {
            times = tarjan(i, times + 1);
        }
    }
}
int main()
{
    int n, u, v, i, j, ans1, ans2, th;
    while (scanf("%d", &n) != EOF)
    {
        th = 0;
        set(n);
        for (u = 1; u <= n; u++)
        {
            while (scanf("%d", &v), v)
            {
                fn[th].v = v, fn[th].next = g[u], g[u] = th++; 
            }
        }
        circle(n);
        for (i = 1; i <= n; i++)
        {
            for (j = g[i]; j != -1; j = fn[j].next)
            {
                v = fn[j].v;
                if (scc[i] != scc[v])
                {
                    flag1[scc[v]] = 1;//scc[v]有入边 
                    flag2[scc[i]] = 1;//scc[i]有出边 
                }
            }
        }
        for (i = 1, ans1 = 0, ans2 = 0; i <= num; i++)
        {
            if (!flag1[i])
            {
                ans1++;
            }
            if (!flag2[i])
            {
                ans2++;
            }
        }
        if (num == 1)
        {
            printf("1\n0\n");
            continue;
        }
        printf("%d\n%d\n", ans1, Max(ans1, ans2));
    }
    //system("pause");
    return 0;
}

火碳黑 2010-09-16 11:05 发表评论

pku 2553 The Bottom of a Graph——强连通分量

火碳黑 — Tue, 14 Sep 2010 04:14:00 GMT

The Bottom of a Graph

Description

We will use the following (standard) definitions from graph theory. Let V be a nonempty and finite set, its elements being called vertices (or nodes). Let E be a subset of the Cartesian product V×V, its elements being called edges. Then G=(V,E) is called a directed graph.
Let n be a positive integer, and let p=(e₁,...,e_n) be a sequence of length n of edges e_i∈E such that e_i=(v_i,v_i+1) for a sequence of vertices (v₁,...,v_n+1). Then p is called a path from vertex v₁ to vertex v_n+1 in G and we say that v_n+1 is reachable from v₁, writing (v₁→v_n+1).
Here are some new definitions. A node v in a graph G=(V,E) is called a sink, if for every node w in G that is reachable from v, v is also reachable from w. The bottom of a graph is the subset of all nodes that are sinks, i.e., bottom(G)={v∈V|∀w∈V:(v→w)⇒(w→v)}. You have to calculate the bottom of certain graphs.

Input

The input contains several test cases, each of which corresponds to a directed graph G. Each test case starts with an integer number v, denoting the number of vertices of G=(V,E), where the vertices will be identified by the integer numbers in the set V={1,...,v}. You may assume that 1<=v<=5000. That is followed by a non-negative integer e and, thereafter, e pairs of vertex identifiers v₁,w₁,...,v_e,w_e with the meaning that (v_i,w_i)∈E. There are no edges other than specified by these pairs. The last test case is followed by a zero.

Output

For each test case output the bottom of the specified graph on a single line. To this end, print the numbers of all nodes that are sinks in sorted order separated by a single space character. If the bottom is empty, print an empty line.

Sample Input

3 3
1 3 2 3 3 1
2 1
1 2
0

Sample Output

1 3
2
题意：求出强连通分量，判断每个分量是否有出边。按序输出没出边的分量里的点。
代码：
#include <stdio.h>
#include <stdlib.h>
#define Min(a, b) a < b ? a : b
#define maxn 5001
struct T
{
    int v, next;
}fn[maxn * maxn];
int g[maxn], visit[maxn], low[maxn], dfn[maxn], stack[maxn], f[maxn], flag[maxn];
int top, id;
void set(int n)
{
    for (int i = 1; i <= n; i++)
    {
        g[i] = -1, visit[i] = 0, f[i] = 0, flag[i] = 0;
    }
}
int dfs(int u, int t)
{
    int i;
    visit[u] = 1;
    stack[top++] = u;
    dfn[u] = low[u] = t;
    for (i = g[u]; i != -1; i = fn[i].next)
    {
        if (!visit[fn[i].v])
        {
            t = dfs(fn[i].v, t + 1);//返回遍历完u的子树的时间 
            low[u] = Min(low[u], low[fn[i].v]);//如果有孩子因为后向边被缩小了low值，则它也相应缩小low值，整个分量的low都取分量中low最小的值。
        }
        else
        {
            if (!f[fn[i].v])//如果f[v]还是0，表示u->v是后向边，v还没出过栈过
            {
                low[u] = Min(low[u], low[fn[i].v]);
            }
        }
    }
    if (dfn[u] == low[u])
    {
        id++;
        do
        {
            f[stack[--top]] = id; 
        }while (top > 0 && stack[top] != u);
    }
    return t;
}
void tarjan(int n)
{
    int t = 0;
    id = 0;
    int i;
    for (i = 1; i <= n; i++)
    {
        if (!visit[i])
        {
            //如果i点能与其它点x构成一个分量，则一定能搜到x，否则，它自己便是一个分量，所以这里的搜索不会重复。
            t = dfs(i, t + 1);
        }
    }
}
int main()
{
    int n, m, u, v, th, k, i, j;
    while (scanf("%d", &n), n)
    {
        scanf("%d", &m);
        th =  0;
        set(n);
        while (m--)
        {
            scanf("%d%d", &u, &v);
            fn[th].v = v, fn[th].next = g[u], g[u] = th++;
        }
        tarjan(n);
        for (i = 1; i <= n; i++)
        { 
            for (j = g[i]; j != -1; j = fn[j].next)
            {
                if (f[fn[j].v] != f[i])//两个点的所在分量不同，表示i有出边 
                {
                    //hash[i] = 1;
                    flag[f[i]] = 1;
                    break;
                }
            }
        }
        for (i = 1; i <= n; i++)
        {
            if (!flag[f[i]])
            {
                if (i != n)
                {
                    printf("%d ", i);
                }
                else
                {
                    printf("%d", i);
                }
            }
        }
        printf("\n");
    }
    system("pause");
    return 0;
}
/*
6 8
1 3
1 2
3 5
5 6
2 4
4 6
3 4
4 1

4 5
1 2
2 3
3 1
1 3
3 4

*/

火碳黑 2010-09-14 12:14 发表评论

1469 COURSES——二分图最大匹配

火碳黑 — Sat, 04 Sep 2010 10:16:00 GMT

COURSES

Description

Consider a group of N students and P courses. Each student visits zero, one or more than one courses. Your task is to determine whether it is possible to form a committee of exactly P students that satisfies simultaneously the conditions:

every student in the committee represents a different course (a student can represent a course if he/she visits that course)
each course has a representative in the committee

Input

Your program should read sets of data from the std input. The first line of the input contains the number of the data sets. Each data set is presented in the following format:

P N
Count1 Student_{1 1} Student_{1 2} ... Student_{1 Count1}
Count2 Student_{2 1} Student_{2 2} ... Student_{2 Count2}
...
CountP Student_{P 1} Student_{P 2} ... Student_{P CountP}

The first line in each data set contains two positive integers separated by one blank: P (1 <= P <= 100) - the number of courses and N (1 <= N <= 300) - the number of students. The next P lines describe in sequence of the courses �from course 1 to course P, each line describing a course. The description of course i is a line that starts with an integer Count i (0 <= Count i <= N) representing the number of students visiting course i. Next, after a blank, you抣l find the Count i students, visiting the course, each two consecutive separated by one blank. Students are numbered with the positive integers from 1 to N.
There are no blank lines between consecutive sets of data. Input data are correct.

Output

The result of the program is on the standard output. For each input data set the program prints on a single line "YES" if it is possible to form a committee and "NO" otherwise. There should not be any leading blanks at the start of the line.

Sample Input

Sample Output

YES
NO
题意：给出课程数跟学生数，以及课程对应的学生。
求是否存在让所有课程跟不同的学生对应。

#include <stdio.h>
#include <stdlib.h>
#define maxn 310
int map[maxn][maxn], hash[maxn], pre[maxn], gn, gm;
//gn左边x的点数，gm右边y的点数 
//pre是右边节点连接x中的节点 
//hash是右边的节点有没有被访问过 
void set()
{
    for (int i = 1; i <= gn; i++)
    {
        for (int j = 1; j <= gm; j++)
        {
            map[i][j] = 0;
        }
    }
    for (int j = 1; j <= gm; j++)
    {
        pre[j] = -1;
    }
}
int han(int u)
{
    for (int v = 1; v <= gm; v++)
    {
        if (hash[v] == 0 && map[u][v])//边存在且右节点没被访问过 
        {
            hash[v] = 1;
            if (pre[v] == -1 || han(pre[v]))//v还没有前置节点或v的前置节点存在增广路 
            {
                pre[v] = u;//设定v的前置节点 
                return 1;
            }
        }
    }
    return 0;
}
int main()
{
    int t, i, j, m, u, v, num;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &gn, &gm);
        set();
        for (i = 1; i <= gn; i++)
        {
            scanf("%d", &m);
            while (m--)
            {
                scanf("%d", &v);
                map[i][v] = 1;
            }
        }
        for (i = 1, num = 0; i <= gn; i++)
        {
            for (j = 1; j <= gm; j++)
            {
                hash[j] = 0;
            }
            if (han(i))
            {
                num++;
            }
        }
        if (num == gn)
        {
            printf("YES\n");
        }
        else
        {
            printf("NO\n");
        }
    }
    system("pause");
    return 0;
}

火碳黑 2010-09-04 18:16 发表评论

1470 Closest Common Ancestors ——Lca

火碳黑 — Sat, 04 Sep 2010 03:52:00 GMT

Closest Common Ancestors

Description

Write a program that takes as input a rooted tree and a list of pairs of vertices. For each pair (u,v) the program determines the closest common ancestor of u and v in the tree. The closest common ancestor of two nodes u and v is the node w that is an ancestor of both u and v and has the greatest depth in the tree. A node can be its own ancestor (for example in Figure 1 the ancestors of node 2 are 2 and 5)

Input

The data set, which is read from a the std input, starts with the tree description, in the form:

nr_of_vertices
vertex:(nr_of_successors) successor1 successor2 ... successorn
...
where vertices are represented as integers from 1 to n ( n <= 900 ). The tree description is followed by a list of pairs of vertices, in the form:
nr_of_pairs
(u v) (x y) ...

The input file contents several data sets (at least one).
Note that white-spaces (tabs, spaces and line breaks) can be used freely in the input.

Output

For each common ancestor the program prints the ancestor and the number of pair for which it is an ancestor. The results are printed on the standard output on separate lines, in to the ascending order of the vertices, in the format: ancestor:times
For example, for the following tree:

Sample Input

5
5:(3) 1 4 2
1:(0)
4:(0)
2:(1) 3
3:(0)
6
(1 5) (1 4) (4 2)
      (2 3)
(1 3) (4 3)

Sample Output

2:1
5:5
题意：给出树的结构，再给出要询问的（u， v),求出询问后公共节点出现的个数。
代码：

#include <stdio.h>
#include <stdlib.h>
#include <vector>
#define maxn 1000
using namespace std;
int visit[maxn], in[maxn], f[maxn], anc[maxn], num[maxn];
vector<int> tree[maxn], que[maxn];
void set(int n)
{
    for (int i = 1; i <= n; i++)
    {
        in[i] = 0;
        visit[i] = 0;
        num[i] = 0;
        anc[i] = i;
        f[i] = -1;
        tree[i].clear();
        que[i].clear();
    }
}
int find(int a)
{
    if (f[a] < 0)
    {
        
        return a;
    }
    return f[a] = find(f[a]);
}
void unions(int a, int b)
{
    a = find(a);
    b = find(b);
    if (a != b)
    {
        if (f[a] > f[b])
        {
            f[b] += f[a];
            f[a] = b;
        }
        else
        {
            f[a] += f[b];
            f[b] = a;
        }
    }
}
void lca(int u)
{
    int i, size;
    size = tree[u].size();
    for (i = 0; i < size; i++)
    {
        lca(tree[u][i]);
        unions(u, tree[u][i]);
        anc[find(u)] = u;
    }
    visit[u] = 1;
    size = que[u].size();
    for (i = 0; i < size; i++)
    {
        if (visit[que[u][i]] == 1)
        {
            num[anc[find(que[u][i])]]++;
        }
    }
}

int main()
{
    char a[100], b[100];
    int n, i, j, u, v, m;
    while (scanf("%d", &n) != EOF)
    {
        set(n);
        for (i = 0; i < n; i++)
        {
            scanf("%d:(%d)", &u, &m);
            for (j = 0; j < m; j++)
            {
                scanf("%d", &v);
                tree[u].push_back(v);
                in[v]++;
            }
        }
        scanf("%d", &m);
        while (m--)
        {
            scanf(" (%d %d)", &u, &v);
            que[u].push_back(v);
            que[v].push_back(u);
        }
        for (i = 1; i <= n; i++)
        {
            if (in[i] == 0)
            {
                lca(i);
                break;
            }
        }
        for (i = 1; i <= n; i++)
        {
            if (num[i])
            {
                printf("%d:%d\n", i, num[i]);
            }
        }
    }
    system("pause");
    return 0;
}

火碳黑 2010-09-04 11:52 发表评论

树同构

火碳黑 — Fri, 27 Aug 2010 02:15:00 GMT

摘要: Bean Language Description In the year 2099, the people in Earth established diplomatic relations between aliens from Pegasus galaxy. The Pegasusan people developed a kind of language called Bean Lan... 阅读全文

火碳黑 2010-08-27 10:15 发表评论

pku 1986——LCA转rmq

火碳黑 — Fri, 13 Aug 2010 07:08:00 GMT

Distance Queries

Description

Farmer John's cows refused to run in his marathon since he chose a path much too long for their leisurely lifestyle. He therefore wants to find a path of a more reasonable length. The input to this problem consists of the same input as in "Navigation Nightmare",followed by a line containing a single integer K, followed by K "distance queries". Each distance query is a line of input containing two integers, giving the numbers of two farms between which FJ is interested in computing distance (measured in the length of the roads along the path between the two farms). Please answer FJ's distance queries as quickly as possible!

Input

* Lines 1..1+M: Same format as "Navigation Nightmare"

* Line 2+M: A single integer, K. 1 <= K <= 10,000

* Lines 3+M..2+M+K: Each line corresponds to a distance query and contains the indices of two farms.

Output

* Lines 1..K: For each distance query, output on a single line an integer giving the appropriate distance.

Sample Input

Sample Output

13
3
36
题意：给出一棵树，其实是个图。求出两点之间的最短距离。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define maxn 600010
int son[maxn], loc[maxn], dis[maxn], sw[maxn], indegree[maxn], th;
struct T
{
    int e, d;
}rmq[maxn*2][30];
struct F
{
    int u, v, w, next; 
}fn[maxn * 2];
void set(int n)
{
    for (int i = 1; i <= n; i++)
    {
        son[i] = 0;
        indegree[i] = 0;
        dis[i] = -1;
        loc[i] = -1;
    }
    for (int i = 1; i <= n; i++)
    {
        fn[i].next = 0;
    }
}
void link(int u, int v, int w)
{
    /*
    树的遍历，这个得记住。节省空间。
    */
    th++;
    fn[th].u = u, fn[th].v = v, fn[th].w = w, fn[th].next = son[u], son[u] = th;
    th++;
    fn[th].u = v, fn[th].v = u, fn[th].w = w, fn[th].next = son[v], son[v] = th;
}
/*
通过搜索来生成树的遍历节点
*/
void dfs(int d, int u, int f, int sd)
{
    int v, i;
    th++;
    if (loc[u] == -1)//只还没出现过的节点在遍历中的时间戳（位置）
    {
        loc[u] = th;
        dis[u] = sd;//距离是叠加的。
    }
    rmq[th][0].e = u;
    rmq[th][0].d = d;
    for (i = son[u]; i; i = fn[i].next)
    {
        if (fn[i].v != f)
        {
            dfs(d + 1, fn[i].v, u, sd + fn[i].w);
            th++;
            rmq[th][0].e = u;
            rmq[th][0].d = d;
        }
    }
}
void build (int n)
{
    int c = log((double)n) / log(2.0), i, j, m;
    for (i = 1; i <= c; i++)
    {
        for (j = 1; j <= n; j++)
        {
            m = j + (1 << (i - 1));
            if (m > n)
            {
                rmq[j][i] = rmq[j][i-1];
            }
            else
            {
                if (rmq[j][i-1].d <= rmq[m][i-1].d)
                {
                    rmq[j][i] = rmq[j][i-1];
                }
                else
                {
                    rmq[j][i] = rmq[m][i-1];
                }
            }
        }
    }
}
int query(int u, int v)
{
    if (loc[u] > loc[v])
    {
        u ^= v;
        v ^= u;
        u ^= v;
    }
    int i = loc[u], j = loc[v];
    int len = j - i + 1;
    int c = log((double)len) / log(2.0);
    int m = j - (1 << c) + 1;
    int ancestor;
    if (rmq[i][c].d <= rmq[m][c].d)
    {
        ancestor = rmq[i][c].e;
    }
    else
    {
        ancestor = rmq[m][c].e;
    }
    return dis[u] + dis[v] - 2 * dis[ancestor];
}
int main()
{
    char c[2];
    int n, m, u, v, w, k, t, i;
    scanf("%d%d", &n, &m);
    set(n);
    th = 0;
    while (m--)
    {
        scanf("%d%d%d%s", &u, &v, &w, c);
        link(u, v, w);
    }
    th = 0;
    dfs(0, 1, 0, 0);
    build (2 * n - 1);
    scanf("%d", &k);
    while (k--)
    {
        scanf("%d%d", &u, &v);
        printf("%d\n", query(u, v));
    }
    return 0;
}

火碳黑 2010-08-13 15:08 发表评论

pku 3368——RMQ

火碳黑 — Wed, 11 Aug 2010 12:25:00 GMT

Frequent values

Description

You are given a sequence of n integers a₁ , a₂ , ... , a_n in non-decreasing order. In addition to that, you are given several queries consisting of indices i and j (1 ≤ i ≤ j ≤ n). For each query, determine the most frequent value among the integers a_i , ... , a_j.

Input

The input consists of several test cases. Each test case starts with a line containing two integers n and q (1 ≤ n, q ≤ 100000). The next line contains n integers a₁ , ... , a_n (-100000 ≤ a_i ≤ 100000, for each i ∈ {1, ..., n}) separated by spaces. You can assume that for each i ∈ {1, ..., n-1}: a_i ≤ a_i+1. The following q lines contain one query each, consisting of two integers i and j (1 ≤ i ≤ j ≤ n), which indicate the boundary indices for the
query.

The last test case is followed by a line containing a single 0.

Output

For each query, print one line with one integer: The number of occurrences of the most frequent value within the given range.

Sample Input

10 3
-1 -1 1 1 1 1 3 10 10 10
2 3
1 10
5 10
0

Sample Output

1
4
3
题意：查找区间内数出现最多的次数

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define maxn 100010
#define Max(a, b) a > b ? a : b
int num[maxn], v[maxn], rq[maxn][20];
void build(int n)
{
    int i, j, m, r = n, c = log((double)n) / log(2.0);
    for (i = 1; i <= n; i++)
    {
        rq[i][0] = v[i];
    }
    for (i = 1; i <= c; i++)
    {
        for (j = 1; j <= r; j++)
        {
            m = j + (1 << (i - 1));a
            if (m <= r)
            {
                rq[j][i] = Max(rq[j][i-1], rq[m][i-1]);
            }
            else
            {
                rq[j][i] = rq[j][i-1];
            }
        }
    }
}
int rmq(int l, int r)
{
    int len = r - l + 1;
    int k = log(double(len)) / log(2.0);
    int m = r - (1 << k) + 1;
    return Max(rq[l][k], rq[m][k]);
}
int query(int l, int r)
{
    int left, i;
    if (num[l] == num[r])
    {
        return r - l + 1;
    }
    for (i = l; ; i++)
    {
        if (v[i] == 1)
        {
            left = i - l;
            break;
        }
    }
    return Max(left, rmq(i, r));
}
int main()
{
    int n, m, i, l, r;
    while (scanf("%d%d", &n, &m) == 2)
    {
        scanf("%d", &num[1]);
        v[1] = 1;
        for (i = 2; i <= n; i++)
        {
            scanf("%d", &num[i]);
            if (num[i] == num[i-1])
            {
                v[i] = v[i-1] + 1;
            }
            else
            {
                v[i] = 1;
            }
        }
        build(n);
        while (m--)
        {
            scanf("%d%d", &l, &r);
            printf("%d\n", query(l, r));
        }
    }
    return 0;
}

火碳黑 2010-08-11 20:25 发表评论

pku 1330——LCA的离线算法tarjan

火碳黑 — Tue, 03 Aug 2010 09:41:00 GMT

Nearest Common Ancestors

Description

A rooted tree is a well-known data structure in computer science and engineering. An example is shown below:

In the figure, each node is labeled with an integer from {1, 2,...,16}. Node 8 is the root of the tree. Node x is an ancestor of node y if node x is in the path between the root and node y. For example, node 4 is an ancestor of node 16. Node 10 is also an ancestor of node 16. As a matter of fact, nodes 8, 4, 10, and 16 are the ancestors of node 16. Remember that a node is an ancestor of itself. Nodes 8, 4, 6, and 7 are the ancestors of node 7. A node x is called a common ancestor of two different nodes y and z if node x is an ancestor of node y and an ancestor of node z. Thus, nodes 8 and 4 are the common ancestors of nodes 16 and 7. A node x is called the nearest common ancestor of nodes y and z if x is a common ancestor of y and z and nearest to y and z among their common ancestors. Hence, the nearest common ancestor of nodes 16 and 7 is node 4. Node 4 is nearer to nodes 16 and 7 than node 8 is.

For other examples, the nearest common ancestor of nodes 2 and 3 is node 10, the nearest common ancestor of nodes 6 and 13 is node 8, and the nearest common ancestor of nodes 4 and 12 is node 4. In the last example, if y is an ancestor of z, then the nearest common ancestor of y and z is y.

Write a program that finds the nearest common ancestor of two distinct nodes in a tree.

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 starts with a line containing an integer N , the number of nodes in a tree, 2<=N<=10,000. The nodes are labeled with integers 1, 2,..., N. Each of the next N -1 lines contains a pair of integers that represent an edge --the first integer is the parent node of the second integer. Note that a tree with N nodes has exactly N - 1 edges. The last line of each test case contains two distinct integers whose nearest common ancestor is to be computed.

Output

Print exactly one line for each test case. The line should contain the integer that is the nearest common ancestor.

Sample Input

Sample Output

4
3
题意：给出树的结构，问两节点的最近公共父节点。
代码：

#include <stdio.h>
#include <vector>
#define maxn 10001
using namespace std;
int visit[maxn], indegree[maxn], f[maxn], ancestor[maxn];
vector<int> tree[maxn], que[maxn];
void init(int n)
{
    int i;
    for (i = 1; i <= n; i++)
    {
        tree[i].clear();
        que[i].clear();
        f[i] = -1;
        visit[i] = 0;
        indegree[i] = 0;
        ancestor[i] = i;
    }
}
int find(int a)
{
    if (f[a] < 0)
    {
        return a;
    }
    return f[a] = find(f[a]);
}
void unions(int a, int b)
{
    a = find(a), b = find(b);
    if (a != b)
    {
        if (f[a] > f[b])
        {
            f[b] += f[a];
            f[a] = b;
        }
        else
        {
            f[a] += f[b];
            f[b] = a;
        }
    }
}
void lca(int u)
{
    int i, size;
    size = tree[u].size();
    for (i = 0; i < size; i++)
    {
        lca(tree[u][i]);
        unions(u, tree[u][i]);
        ancestor[find(u)] = u;
        /*对于处理过的孩子，其祖先要改为当前节点，保证这棵数的遍历逻辑，
        因为并查集的合并是按权值而非遍历顺序合并的,通过并查集高效获得子树集合的端口，在通过这端口获得
        该子树在这个时间段的真正最近父节点，如图中的4在并查树中会被归并为6的孩子，因为权值的问题*/
    }
    visit[u] = 1;
    size = que[u].size();
    for (i = 0; i < size; i++)
    {
        if (visit[que[u][i]] == 1)
        {
            printf("%d\n", ancestor[find(que[u][i])]);
            return;
        }
    }
}
int main()
{
    int n, t, i, u, v;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        init(n);
        for (i = 1; i < n; i++)
        {
            scanf("%d%d", &u, &v);
            tree[u].push_back(v);
            indegree[v]++;
        }
        scanf("%d%d", &u, &v);
        que[u].push_back(v);
        que[v].push_back(u);
        for (i = 1; i <= n; i++)
        {
            if (indegree[i] == 0)
            {
                lca(i);
                break;
            }
        }
    }
    return 0;
}

火碳黑 2010-08-03 17:41 发表评论

pku 3264 ——rmq问题的st算法

火碳黑 — Fri, 30 Jul 2010 07:35:00 GMT

rmq范围最小（大）指问题——处理对于n个数，要求快速求出某区间内的最值。
f[i][j]表示以i为起点长度为2^j的最值。
f[i][j] = rmq(f[i][j-1], f[i + 2 ^ (j-1)][j-1];相当于把线段分成相等的左右两段合并求rmq。但这得让线段长度是2的幂次。
查询时，例如f[1，7] = f[1][2] + f[5][1] + f[7][0];为O(logn),f[1, 7]对应于数组中的区间
为了加快查询，可使f[1，7] = f[1][2] + f[4][2];为O(1)，这里用2=（2^k <= 7）k的最大值7 - 2^2 + 1 为4，即让7向左移动2^2 - 1个位，2^k = 1 << k;注意：例如给出n=7，则f[4][2]是求对应于[4, 8]的rmq，而f[4, 8] = f[4, 7],所以要对此进行预处理,让右区间的值超过n的为右区间为n时的值，这样才能加快查询，即多增加了一些方便查询的数据。最大左移是k = log2(n),可表示的最大起始点是1 << k,则f[i][j]表示的右区间的最大值为
(1 << k) + (1 << k) = 1 << (k + 1) = 2 ^ (log2(n) + 1),提供这个数据时能给出何时得空间[n + 1][log2(n) + 1 + 1]。
代码：

#include < stdio.h >
#include < stdlib.h >
#include < math.h >
#define maxn 50010
#define Min(a, b) a < b ? a : b
#define Max(a, b) a > b ? a : b
struct t
{
     int min, max;
}map[maxn][ 20 ];
void build ( int n)
{
     int i, j, m, r = n, c = log(( double )n) / log( 2.0 );
     for (i = 1 ; i <= c; i ++ )
    {
         for (j = 1 ; j <= r; j ++ )
        {
            m = j + ( 1 << (i - 1 )); // 右半部分的起始值
             if (m <= r)
            {
                map[j][i].min = Min(map[j][i - 1 ].min ,map[m][i - 1 ].min);
                map[j][i].max = Max(map[j][i - 1 ].max, map[m][i - 1 ].max);
            }
             else // 长度超出n的，就当是j起点的最后一个终点的rmq。实现这步能使查询为O(1).
            {
                map[j][i].min = map[j][i - 1 ].min;
                map[j][i].max = map[j][i - 1 ].max;
            }
        }
    }
}
int query( int l, int r)
{
     int len = r - l + 1 ;
     int k = log(( double )len) / log( 2.0 );
     int m = r - ( 1 << k) + 1 ;
     int min = Min(map[l][k].min, map[m][k].min);
     int max = Max(map[l][k].max, map[m][k].max);
     return max - min;
}
int main()
{
     int n, m,  i, l, r;
    scanf( " %d%d " , & n, & m);
     for (i = 1 ; i <= n; i ++ )
    {
        scanf( " %d " , & map[i][ 0 ].min);
        map[i][ 0 ].max = map[i][ 0 ].min;
    }
    build (n);
     while (m -- )
    {
        scanf( " %d%d " , & l, & r);
        printf( " %d\n " , query(l, r));
    }
     return 0 ;
}

火碳黑 2010-07-30 15:35 发表评论

C++博客-夜幻梦回-文章分类-图论

树的最长路径L —— 具有:所有除了L上的点的叶子点到L的距离最长这最小

Highway Construction

Description

Input

Output

Sample Input

Sample Output

poj 2987——最大闭权图 运用最大流dinic

pku 1486 Sorting Slides ——二分图最大匹配

本校oj马哥题，

pku 3621 Sightseeing Cows——spfa判断负环

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

pku 3013 Big Christmas Tree——最短路spfa

pku 3207 Ikki's Story IV - Panda's Trick——2-sat判定性问题

pku 3177 Redundant Paths——无向图双连通分量缩点

pku 3352 Road Construction——无向图强连通分量

pku 1236 Network of Schools——强连通分量缩点求入度分量为0个数和出度为0的分量个数

pku 2553 The Bottom of a Graph——强连通分量

1469 COURSES——二分图最大匹配

1470 Closest Common Ancestors ——Lca

树同构

pku 1986——LCA转rmq

pku 3368——RMQ

pku 1330——LCA的离线算法tarjan

pku 3264 ——rmq问题的st算法

poj 2987——最大闭权图运用最大流dinic