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

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

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

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

pku 3667——线段树

火碳黑 — Sun, 25 Jul 2010 02:53:00 GMT

#include < stdio.h >
#define maxn 50005
struct
{
     /*
    ml线段左边的最大空位，mr线段右边的最大空位，mm线段的最大空位，f线段最大空位的起始位置
    cov线段是否被覆盖，ud线段被覆盖时，有没有往下将更改传递给孩子，len线段的长度
     */
     int l, r, ml, mr, mm, f, cov, ud, len;
}tree[maxn * 3 ];
void build ( int l, int r, int i)
{
    tree[i].l = l, tree[i].r = r;
    tree[i].ml = tree[i].mr = tree[i].len = tree[i].mm = r - l + 1 ;
    tree[i].f = tree[i].l;
    tree[i].cov = tree[i].ud = 0 ;
     if (l == r)
    {
         return ;
    }
     int m = (l + r) / 2 ;
    build (l, m , i * 2 ), build (m + 1 , r, i * 2    + 1 );
}
void down( int i)
{
     /*
    往下传递改节点的覆盖信息，如果往下传递，则更新孩子的数据
    因为赖操作是针对已经确定被更新的线段的整块区域，所以不管孩子的在没修改之前的信息如何，都要被覆盖。孩子之前的信息已经没用了。
     */
     if (tree[i].ud) // tree[i].ud为1时，表示该节点的覆盖信息还没传递到孩子，否则，表示该节点的信息已经传递给孩子了
    {
         // 对自己的更改
         if (tree[i].cov)
        {
            tree[i].ml = tree[i].mr = tree[i].mm = 0 ;
        }
         else
        {
            tree[i].ml = tree[i].mr = tree[i].mm = tree[i].r - tree[i].l + 1 ;
            tree[i].f = tree[i].l;
        }
         // 对孩子的更改，由于对于赖操作的更细传递到该节点，如果要利用到孩子节点的信息，所以也要修改孩子的数据
         if (tree[i].l != tree[i].r)
        {
            tree[i * 2 ].cov = tree[i * 2 + 1 ].cov = tree[i].cov;
            tree[i * 2 ].ud = tree[i * 2 + 1 ].ud = 1 ;
             if (tree[i].cov)
            {
                tree[i * 2 ].ml = tree[i * 2 ].mr = tree[i * 2 ].mm = 0 ;
                tree[i * 2 + 1 ].ml = tree[i * 2 + 1 ].mr = tree[i * 2 + 1 ].mm = 0 ;
            }
             else
            {
                tree[i * 2 ].ml = tree[i * 2 ].mr = tree[i * 2 ].mm = tree[i * 2 ].r - tree[i * 2 ].l + 1 ;
                tree[i * 2 ].f = tree[i * 2 ].l;
                tree[i * 2 + 1 ].ml = tree[i * 2 + 1 ].mr = tree[i * 2 + 1 ].mm = tree[i * 2 + 1 ].r - tree[i * 2 + 1 ].l + 1 ;
                tree[i * 2 + 1 ].f = tree[i * 2 + 1 ].l;
            }
        }
        tree[i].ud = 0 ;
    }
}
void insert( int l, int r, int i, int cov)
{
     if (tree[i].l >= l && tree[i].r <= r) // 线段在更新范围内，则只需将修改信息传递给孩子，并修改必要的数据后直接返回
    {
        tree[i].cov = cov;
        tree[i].ud = 1 ;
        down(i);
         return ;
    }
    down(i);
     int m = (tree[i].l + tree[i].r) >> 1 ;
     if (l > m)
    {
        insert(l, r, i * 2 + 1 , cov);
    }
     else if (m >= r)
    {
        insert(l, r, i * 2 , cov);
    }
     else
    {
        insert(l, r, i * 2 , cov), insert(l, r, i * 2 + 1 , cov);
    }
     // 由于改线段没被覆盖，数据的信息要通过孩子的信息来结合修改。
    tree[i].ml = tree[i * 2 ].ml, tree[i].mr = tree[i * 2 + 1 ].mr;
     if (tree[i * 2 ].ml == tree[i * 2 ].len)
    {
        tree[i].ml += tree[i * 2 + 1 ].ml;
    }
     if (tree[i * 2 + 1 ].mr == tree[i * 2 + 1 ].len)
    {
        tree[i].mr += tree[i * 2 ].mr;
    }
    tree[i].mm = tree[i * 2 ].mm;
    tree[i].f = tree[i * 2 ].f;
     if (tree[i].mm < tree[i * 2 ].mr + tree[i * 2 + 1 ].ml)
    {
        tree[i].mm = tree[i * 2 ].mr + tree[i * 2 + 1 ].ml;
        tree[i].f = tree[i * 2 ].r - tree[i * 2 ].mr + 1 ;
    }
     if (tree[i].mm < tree[i * 2 + 1 ].mm)
    {
        tree[i].mm = tree[i * 2 + 1 ].mm;
        tree[i].f = tree[i * 2 + 1 ].f;
    }
}
int find( int len, int i)
{
    down(i);
     if (tree[i].ml >= len)
    {
         return tree[i].l;
    }
     else if (tree[i * 2 ].mm >= len)
    {
         return find (len, i * 2 );
    }
     else if (tree[i * 2 ].mr + tree[i * 2 + 1 ].ml >= len)
    {
         return tree[i * 2 ].r - tree[i * 2 ].mr + 1 ;
    }
     else if (tree[i * 2 + 1 ].mm >= len)
    {
         return find (len, i * 2 + 1 );
    }
     return 0 ;
}
int main()
{
     int n, m, op, d, x, ans;
    scanf( " %d%d " , & n, & m);
    build ( 1 , n, 1 );
     while (m -- )
    {
        scanf( " %d " , & op);
         if (op == 1 )
        {
            scanf( " %d " , & d);
            ans = find(d, 1 );
            printf( " %d\n " , ans);
             if (ans)
            {
                insert(ans, ans + d - 1 , 1 , 1 );
            }
        }
         else if (op == 2 )
        {
            scanf( " %d%d " , & x, & d);
            insert(x, x + d - 1 , 1 , 0 );
        }
    }
     return 0 ;
}

火碳黑 2010-07-25 10:53 发表评论

pku 2104 K-th Number__线段树

火碳黑 — Mon, 24 May 2010 09:50:00 GMT

K-th Number

Description

You are working for Macrohard company in data structures department. After failing your previous task about key insertion you were asked to write a new data structure that would be able to return quickly k-th order statistics in the array segment.
That is, given an array a[1...n] of different integer numbers, your program must answer a series of questions Q(i, j, k) in the form: "What would be the k-th number in a[i...j] segment, if this segment was sorted?"
For example, consider the array a = (1, 5, 2, 6, 3, 7, 4). Let the question be Q(2, 5, 3). The segment a[2...5] is (5, 2, 6, 3). If we sort this segment, we get (2, 3, 5, 6), the third number is 5, and therefore the answer to the question is 5.

Input

The first line of the input file contains n --- the size of the array, and m --- the number of questions to answer (1 <= n <= 100 000, 1 <= m <= 5 000).
The second line contains n different integer numbers not exceeding 10⁹ by their absolute values --- the array for which the answers should be given.
The following m lines contain question descriptions, each description consists of three numbers: i, j, and k (1 <= i <= j <= n, 1 <= k <= j - i + 1) and represents the question Q(i, j, k).

Output

For each question output the answer to it --- the k-th number in sorted a[i...j] segment.

Sample Input

7 3
1 5 2 6 3 7 4
2 5 3
4 4 1
1 7 3

Sample Output

5
6
3

代码：

#include<stdio.h>
#include<stdlib.h>
#define maxn 100010
struct T
{
    int l, r, dep;
    T * pl, *pr;
}fn[maxn * 3];
int th = 0, a, b, sort[30][maxn], s[maxn], s1, s2;
T * build(int l, int r, int dep)
{
    T * p = &fn[th++];
    p->l = l, p->r = r, p->dep = dep;
    if (l == r)
    {
        sort[dep][l] = s[l];
    }
    else
    {
        int m = (l + r) / 2, i, j, k;
        p->pl = build(l, m, dep + 1), p->pr = build(m + 1, r, dep + 1);
        for (k = i = l, j = m + 1;i <= m && j <= r;)
        {
            if (sort[dep + 1][i] < sort[dep + 1][j])
            {
                sort[dep][k++] = sort[dep + 1][i++];
            }
            else
            {
                sort[dep][k++] = sort[dep + 1][j++];
            }
        }
        for (; i <= m; i++)
        {
            sort[dep][k++] = sort[dep + 1][i];
        }
        for (; j <= r; j++)
        {
            sort[dep][k++] = sort[dep + 1][j];
        }
    }
    return p;
}
int query(T * p, int num)
{
    int m, l, r, t;
//确定所询问区间里排在num前的数的个数
    if (a <= p->l && p->r <= b)
    {
        l = p->l, r = p->r;
        if (sort[p->dep][p->r] <= num)
        {
            return r - l + 1;
        }
        while (l < r)
        {
            m = (l + r) / 2;
            if (sort[p->dep][m] > num)
            {
                r = m;
            }
            else
            {
                l = m + 1;
            }
        }
        return r - p->l;
    }
    else
    {
        m = (p->l + p->r) / 2;
        t = 0;
        if (a <= m)
        {
            t += query(p->pl, num);
        }
        if (b > m)
        {
            t += query(p->pr, num);
        }
        return t;
    }
}
int main()
{
    int n, m, i, l, r, mid, pre, c;
    scanf("%d%d", &n, &m);
    for (i = 1; i <= n; i++)
    {
        scanf("%d", &s[i]);
    }
    T * tree = build(1, n, 0);
    while (m--)
    {
        scanf("%d%d%d", &a, &b, &c);
        l = 1, r = n;
        while (l < r)//二分枚举数来确定其名次
        {
            mid = (l + r) / 2;
            pre = query(tree, sort[0][mid]);
            if (pre >= c)
            {
                r = mid;
            }
            else
            {
                l = mid + 1;
            }
        }
        printf("%d\n", sort[0][l]);
    }
    system("pause");
    return 0;
}
/*
7 100
5 3 2 9 8 1 6

*/

火碳黑 2010-05-24 17:50 发表评论

pku 1151 Atlantis——线段树

火碳黑 — Mon, 24 May 2010 07:52:00 GMT

Atlantis

Description

There are several ancient Greek texts that contain descriptions of the fabled island Atlantis. Some of these texts even include maps of parts of the island. But unfortunately, these maps describe different regions of Atlantis. Your friend Bill has to know the total area for which maps exist. You (unwisely) volunteered to write a program that calculates this quantity.

Input

The input consists of several test cases. Each test case starts with a line containing a single integer n (1 <= n <= 100) of available maps. The n following lines describe one map each. Each of these lines contains four numbers x1;y1;x2;y2 (0 <= x1 < x2 <= 100000;0 <= y1 < y2 <= 100000), not necessarily integers. The values (x1; y1) and (x2;y2) are the coordinates of the top-left resp. bottom-right corner of the mapped area.
The input file is terminated by a line containing a single 0. Don't process it.

Output

For each test case, your program should output one section. The first line of each section must be "Test case #k", where k is the number of the test case (starting with 1). The second one must be "Total explored area: a", where a is the total explored area (i.e. the area of the union of all rectangles in this test case), printed exact to two digits to the right of the decimal point.
Output a blank line after each test case.

Sample Input

2
10 10 20 20
15 15 25 25.5
0

Sample Output

Test case #1
Total explored area: 180.00

题意：切割矩形。
先计算绿色部分，在计算橙色部分，再计算蓝色部分。

#include < stdio.h >
#include < stdlib.h >
#define maxn 500
struct T
{
     int l, r, cov;
     double len;
}tree[maxn * 5 ];
struct R
{
     double x, y1, y2;
     int lr;
}rec[maxn * 2 ];
double y[maxn * 2 ];
int cmp1( const void * a, const void * b)
{
     double aa = * (( double * )a), bb = * (( double * )b);
     if (aa > bb)
    {
         return 1 ;
    }
     if (aa == bb)
    {
         return 0 ;
    }
     return - 1 ;
}
int cmp2( const void * a, const void * b)
{
    R aa = * ((R * )a), bb = * ((R * )b);
     if (aa.x > bb.x)
    {
         return 1 ;
    }
     if (aa.x == bb.x)
    {
         return 0 ;
    }
     return - 1 ;
}
void build( int l, int r, int th)
{
    tree[th].l = l, tree[th].r = r, tree[th].cov = 0 , tree[th].len = 0 ;
     if (l + 1 == r)
    {
         return ;
    }
     int m = (l + r) >> 1 ;
    build(l, m, th * 2 ), build(m, r, th * 2 + 1 );
}
void op( int l, int r, int th, int del) // 由于对于竖直边，肯定先插入在删除，所以这里写的不是很符合所有的插入删除统计。
{
     if (tree[th].l == l && tree[th].r == r)
    {
        tree[th].cov += del;
         if (tree[th].cov > 0 )
        {
            tree[th].len = y[r] - y[l];
        }
         else
        {
            tree[th].len = tree[th * 2 ].len + tree[th * 2 + 1 ].len;
        }
         return ;
    }
     int m = (tree[th].l + tree[th].r) >> 1 ;
     if (r <= m)
    {
        op(l, r, th * 2 , del);
    }
     else if (l >= m)
    {
        op(l, r, th * 2 + 1 , del);
    }
     else
    {
        op(l, m, th * 2 , del), op(m, r, th * 2 + 1 , del);
    }
     if (tree[th].cov > 0 )
    {
        tree[th].len = y[tree[th].r] - y[tree[th].l];
    }
     else
    {
        tree[th].len = tree[th * 2 ].len + tree[th * 2 + 1 ].len;
    }
}
int bs( int l, int r, double key)
{
     int m;
     while (l <= r)
    {
        m = (l + r) >> 1 ;
         if (y[m] > key)
        {
            r = m - 1 ;
        }
         else if (y[m] < key)
        {
            l = m + 1 ;
        }
         else
        {
             return m;
        }
    }
}
int main()
{
     int n, i, j, k, l, r, ca = 0 ;
     double ans, x1, y1, x2, y2;
     while (scanf( " %d " , & n), n)
    {
        ca ++ ;
         for (i = 0 , j = 0 ; i < n; i ++ )
        {
            scanf( " %lf%lf%lf%lf " , & x1, & y1, & x2, & y2);
            y[j] = y1, rec[j].x = x1, rec[j].y1 = y1, rec[j].y2 = y2, rec[j ++ ].lr = 1 ;
            y[j] = y2, rec[j].x = x2, rec[j].y1 = y1, rec[j].y2 = y2, rec[j ++ ].lr = - 1 ;
        }
        qsort(y, j, sizeof ( double ), cmp1);
        qsort(rec, j, sizeof (R), cmp2);
         for (k = i = 1 ; i < j; i ++ ) // 坐标离散化
        {
             if (y[i] != y[i - 1 ])
            {
                y[k ++ ] = y[i];
            }
        }
        build( 0 , k, 1 );
        k -- ;
         for (i = 0 , ans = 0 ; i < j - 1 ; i ++ )
        {
            l = bs( 0 , k, rec[i].y1), r = bs( 0 , k, rec[i].y2);
            op(l, r, 1 , rec[i].lr);
            ans += 1.0 * tree[ 1 ].len * (rec[i + 1 ].x - rec[i].x);
        }
        printf( " Test case #%d\nTotal explored area: %.2lf\n\n " , ca, ans);
    }
    system( " pause " );
     return 0 ;
}

火碳黑 2010-05-24 15:52 发表评论

pku 3468 A Simple Problem with Integers——线段树

火碳黑 — Wed, 19 May 2010 02:37:00 GMT

A Simple Problem with Integers

Description

You have N integers, A₁, A₂, ... , A_N. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.

Input

The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A₁, A₂, ... , A_N. -1000000000 ≤ A_i ≤ 1000000000.
Each of the next Q lines represents an operation.
"C abc" means adding c to each of A_a, A_a₊₁, ... , A_b. -10000 ≤ c ≤ 10000.
"Q ab" means querying the sum of A_a, A_a₊₁, ... , A_b.

Output

You need to answer all Q commands in order. One answer in a line.

Sample Input

10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4

Sample Output

4
55
9
15
代码：

#include < stdio.h >
#include < stdlib.h >
#define maxn 100010
struct T
{
     int l, r;
    __int64 value, delta;
}tree[ 5 * maxn];
__int64 v[maxn];
void build( int l, int r, int th)
{
    tree[th].l = l, tree[th].r = r, tree[th].delta = 0 ;
     if (l == r)
    {
        tree[th].value = v[l];
         return ;
    }
     int k = (l + r) / 2 ;
    build(l, k, th * 2 );
    build(k + 1 , r, th * 2 + 1 );
    tree[th].value = tree[th * 2 ].value + tree[th * 2 + 1 ].value;
}
void update( int l, int r, int th, __int64 d)
{
    tree[th].value += (r - l + 1 ) * d;
     if (tree[th].delta)
    {
        tree[th].value += (tree[th].r - tree[th].l + 1 ) * tree[th].delta; // 检查更新
        tree[th * 2 ].delta += tree[th].delta, tree[th * 2 + 1 ].delta += tree[th].delta; // 把孩子的delta更新，即赖操作
        tree[th].delta = 0 ;
    }
     if (tree[th].l == l && tree[th].r == r)
    {
        tree[th * 2 ].delta += d, tree[th * 2 + 1 ].delta += d;
         return ;
    }
     int k = (tree[th].l + tree[th].r) / 2 ;
     if (r <= k)
    {
        update(l, r, th * 2 , d);
    }
     else if (l >= k + 1 )
    {
        update(l, r, th * 2 + 1 , d);
    }
     else
    {
        update(l, k, th * 2 , d), update(k + 1 , r, th * 2 + 1 , d);
    }
}
__int64 sum( int l, int r, int th)
{
     if (tree[th].delta)
    {
        tree[th].value += (tree[th].r - tree[th].l + 1 ) * tree[th].delta;
        tree[th * 2 ].delta += tree[th].delta, tree[th * 2 + 1 ].delta += tree[th].delta;
        tree[th].delta = 0 ;
    }
     if (tree[th].l == l && tree[th].r == r)
    {
         return tree[th].value;
    }
     int k = (tree[th].l + tree[th].r) / 2 ;
     if (r <= k)
    {
         return sum(l, r, th * 2 );
    }
     else if (l >= k + 1 )
    {
         return sum(l, r, th * 2 + 1 );
    }
     else
    {
         return sum(l, k, th * 2 ) + sum(k + 1 , r, th * 2 + 1 );
    }
}
int main()
{
     int n, m, i, x, y;
    __int64 delta;
     char op[ 2 ];
    scanf( " %d%d " , & n, & m);
     for (i = 1 ; i <= n; i ++ )
    {
        scanf( " %I64d " , & v[i]);
    }
    build( 1 , n, 1 );
     while (m -- )
    {
        scanf( " %s " , op);
         if ( * op == ' Q ' )
        {
            scanf( " %d%d " , & x, & y);
            printf( " %I64d\n " , sum(x, y, 1 ));
        }
         else
        {
            scanf( " %d%d%I64d " , & x, & y, & delta);
            update(x, y, 1 , delta);
        }
    }
    system( " pause " );
     return 0 ;
}

火碳黑 2010-05-19 10:37 发表评论

pku 3321 Apple Tree——树状数组

火碳黑 — Thu, 13 May 2010 14:37:00 GMT

Apple Tree

Description

There is an apple tree outside of kaka's house. Every autumn, a lot of apples will grow in the tree. Kaka likes apple very much, so he has been carefully nurturing the big apple tree.

The tree has N forks which are connected by branches. Kaka numbers the forks by 1 to N and the root is always numbered by 1. Apples will grow on the forks and two apple won't grow on the same fork. kaka wants to know how many apples are there in a sub-tree, for his study of the produce ability of the apple tree.

The trouble is that a new apple may grow on an empty fork some time and kaka may pick an apple from the tree for his dessert. Can you help kaka?

Input

The first line contains an integer N (N ≤ 100,000) , which is the number of the forks in the tree.
The following N - 1 lines each contain two integers u and v, which means fork u and fork v are connected by a branch.
The next line contains an integer M (M ≤ 100,000).
The following M lines each contain a message which is either
"C x" which means the existence of the apple on fork x has been changed. i.e. if there is an apple on the fork, then Kaka pick it; otherwise a new apple has grown on the empty fork.
or
"Q x" which means an inquiry for the number of apples in the sub-tree above the fork x, including the apple (if exists) on the fork x
Note the tree is full of apples at the beginning

Output

For every inquiry, output the correspond answer per line.

Sample Input

Sample Output

3
2
题意：给出一颗树，对某个节点进行操作，如果有苹果，则摘；没有，则长个苹果。求某个节点拥有的苹果数量，每个节点最多只有一个苹果。
代码：

#include<stdio.h>
#include<stdlib.h>
#define maxn 100020
int low[maxn], high[maxn], n, c[maxn], t[maxn];
struct P
{
    int pt, head;
}p[maxn];
struct N
{
    int pt, id;
}node[maxn];
int th = 0, time = 0;
int create(int id)
{
    th++;
    node[th].pt = -1, node[th].id = id;
    return th;
}
int lowbit(int x)
{
    return x & (-x);
}
void update(int x, int y)
{
    while (x <= n)
    {
        c[x] += y;
        x += lowbit(x);
    }
}
int sum(int x)
{
    int s = 0;
    while (x > 0)
    {
        s += c[x];
        x -= lowbit(x);
    }
    return s;
}
void dfs(int root)
{
    int v = p[root].head;
    time++;//添加时间戳 ，就可以是问题转化为求区间和 
    low[root] = time;
    for (v = p[root].head; v != -1; v = node[v].pt)
    {
        dfs(node[v].id);
    }
    high[root] = time;
}
int main()
{
    int i, u, v, no, m, x, num;
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
    {
        p[i].pt = -1, p[i].head = -1;
        update(i, 1);
        t[i] = 1;
    }
    num = n;
    while (--num)
    {
        scanf("%d%d", &u, &v);
        no = create(v);
        node[p[u].pt].pt = no;
        p[u].pt = no;
        if (p[u].head == -1)
        {
            p[u].head = no;
        }
    }
    dfs(1);
    char a[2];
    scanf("%d", &m);
    while (m--)
    {
        scanf("%s%d", a, &x);
        if (a[0] == 'Q')
        {
            printf("%d\n", sum(high[x]) - sum(low[x] - 1));
        }
        else
        {
            if (t[x])
            {
                update(low[x], -1);
                t[x] = 0;
            }
            else
            {
                update(low[x], 1);
                t[x] = 1;
            }
        }
    }
    system("pause");
    return 0;
}
/*
5
1 2
1 3
3 4
3 5
*/

火碳黑 2010-05-13 22:37 发表评论

pku 2352 Stars__树状数组

火碳黑 — Thu, 13 May 2010 12:32:00 GMT

Stars

Description

Astronomers often examine star maps where stars are represented by points on a plane and each star has Cartesian coordinates. Let the level of a star be an amount of the stars that are not higher and not to the right of the given star. Astronomers want to know the distribution of the levels of the stars.

For example, look at the map shown on the figure above. Level of the star number 5 is equal to 3 (it's formed by three stars with a numbers 1, 2 and 4). And the levels of the stars numbered by 2 and 4 are 1. At this map there are only one star of the level 0, two stars of the level 1, one star of the level 2, and one star of the level 3.

You are to write a program that will count the amounts of the stars of each level on a given map.

Input

The first line of the input file contains a number of stars N (1<=N<=15000). The following N lines describe coordinates of stars (two integers X and Y per line separated by a space, 0<=X,Y<=32000). There can be only one star at one point of the plane. Stars are listed in ascending order of Y coordinate. Stars with equal Y coordinates are listed in ascending order of X coordinate.

Output

The output should contain N lines, one number per line. The first line contains amount of stars of the level 0, the second does amount of stars of the level 1 and so on, the last line contains amount of stars of the level N-1.

Sample Input

Sample Output

题意：某星左下方的星数为它的值。求出值从0到n-1的星数。
代码：

#include < stdio.h >
#define maxn 32010
int c[maxn], sum[maxn];
int lowBit( int x)
{
     return x & (x ^ (x - 1 ));//return x & (-x);更快
}
void update( int x)
{
     while (x < maxn)
    {
        c[x] ++ ;
        x += lowBit(x);
    }
}
int s( int x)
{
     int pre = 0 ;
     while (x > 0 )
    {
        pre += c[x];
        x -= lowBit(x);
    }
     return pre;
}
int main()
{
     int i, n, x, y;
    scanf( " %d " , & n);
     for (i = 0 ; i < n; i ++ )
    {
        scanf( " %d%d " , & x, & y); // 树状数组的坐标是从1开始
        sum[s(x + 1 )] ++ ;
        update(x + 1 );
    }
     for (i = 0 ; i < n; i ++ )
    {
        printf( " %d\n " , sum[i]);
    }
    system( " pause " );
     return 0 ;
}

火碳黑 2010-05-13 20:32 发表评论

pku 1414 Life Line 简单搜索

火碳黑 — Thu, 06 May 2010 15:00:00 GMT

Life Line

Description

Let's play a new board game "Life Line".
The number of the players is greater than 1 and less than 10.
In this game, the board is a regular triangle in which many small regular triangles are arranged (See Figure 1). The edges of each small triangle are of the same length.

The size of the board is expressed by the number of vertices on the bottom edge of the outer triangle.For example, the size of the board in Figure 1 is 4.

At the beginning of the game, each player is assigned his own identification number between 1 and 9,and is given some stones on which his identification number is written.

Each player puts his stone in turn on one of the "empty" vertices. An "empty vertex" is a vertex that has no stone on it.

When one player puts his stone on one of the vertices during his turn, some stones might be removed from the board. The player gains points which is equal to the number of the removed stones of himself. The points of a player for a single turn is the points he gained minus the points he lost in that turn.

The conditions for removing stones are as follows :

1.The stones on the board are divided into groups. Each group contains a set of stones whose numbersare the same and placed adjacently. That is, if the same numbered stones are placed adjacently,they belong to the same group.

2.If none of the stones in a group is adjacent to at least one "empty" vertex, all the stones in that group are removed from the board.

Figure 2 shows an example of the groups of stones.

Suppose that the turn of the player '4' comes now. If he puts his stone on the vertex shown in Figure 3a, the conditions will be satisfied to remove some groups of stones (shadowed in Figure 3b). The player gains 6 points, because the 6 stones of others are removed from the board (See Figure 3c).

As another example, suppose that the turn of the player '2' comes in Figure 2. If the player puts his

stone on the vertex shown in Figure 4a, the conditions will be satisfied to remove some groups of stones (shadowed in Figure 4b). The player gains 4 points, because the 4 stones of others are removed. But, at the same time, he loses 3 points, because his 3 stones are removed. As the result, the player's points of this turn is 4 ? 3 = 1 (See Figure 4c).

When each player puts all of his stones on the board, the game is over. The total score of a player is the summation of the points of all of his turns.

Your job is to write a program that tells you the maximum points a player can get (i.e., the points he gains - the points he loses) in his current turn.

Input

The input consists of multiple data. Each data represents the state of the board of the game still in

progress. The format of each data is as follows.

N C
       S_1,1
     S_2,1 S_2,2
   S_3,1 S_3,2 S_3,3
    . . .
S_N,1 . . . S_N,N

N is the size of the board (3 <= N <= 10). C is the identification number of the player whose turn comes now (1 <= C <= 9). That is, your program must calculate his points in this turn. S_i,j is the state of the vertex on the board (0 <= Si,j <= 9). If the value of Si,j is positive, it means that there is the stone numbered by Si,j there. If the value of S_i,j is 0, it means that the vertex is "empty". Two zeros in a line, i.e., 0 0, represents the end of the input.

Output

For each data, the maximum points the player can get in the turn should be output, each in a separate line.

Sample Input

4 4
   2
  2 3
 1 0 4
1 1 4 0
4 5
   2
  2 3
 3 0 4
1 1 4 0
4 1
   2
  2 3
 3 0 4
1 1 4 0
4 1
   1
  1 1
 1 1 1
1 1 1 0
4 2
   1
  1 1
 1 1 1
1 1 1 0
4 1
   0
  2 2
 5 0 7
0 5 7 0
4 2
   0
  0 3
 1 0 4
0 1 0 4
4 3
   0
  3 3
 3 2 3
0 3 0 3
4 2
   0
  3 3
 3 2 3
0 3 0 3
6 1
     1
    1 2
   1 1 0
  6 7 6 8
 0 7 6 8 2
6 6 7 2 2 0
5 9
    0
   0 0
  0 0 0
 0 0 0 0
0 0 0 0 0
5 3
    3
   3 2
  4 3 2
 4 4 0 3
3 3 3 0 3
0 0

Sample Output

6
5
1
-10
8
-1
0
1
-1
5
0
5
代码：

#include<stdio.h>
#define Max(a, b) a > b ? a : b
#define maxn 15
int M[6][2] = { {0, -1}, {-1, -1}, {-1, 0}, {0, 1}, {1, 1}, {1, 0} };
int map[maxn][maxn], visit[maxn][maxn], e[3*maxn][2];
int n, len, sign, sum, m;
void set()
{
    int i, j;
    for (i = 0; i < n; i++)
    {
        for (j = 0; map[i][j] != -1; j++)
        {
            visit[i][j] = 0;
        }
    }
}
int dfs(int x, int y)
{
    int i, xx, yy;
    visit[x][y] = 1;
    sum++;
    for (i = 0; i < 6; i++)
    {
        xx = x + M[i][0], yy = y + M[i][1];
        if (xx >= 0 && xx < n && yy >= 0 && map[xx][yy] != -1)
        {
            if (!visit[xx][yy] && map[xx][yy] == map[x][y])
            {            
                dfs(xx, yy);
            }
            else if (map[xx][yy] == 0)
            {
                sign = 0;
            }
        }
    }
}
int work()
{
    int i, j, all;
    for (i = 0, all = 0; i < n; i++)
    {
        for (j = 0; map[i][j] != -1; j++)
        {
            if (!visit[i][j] && map[i][j] != 0)
            {
                sum = 0;
                sign = 1;
                dfs(i, j);
                if (sign)
                {
                    if (map[i][j] == m)
                    {
                        all -= sum;
                    }
                    else
                    {
                        all += sum;
                    }
                }
            }
        }
    }
    return all;
}
int main()
{
    int i, j, max, x, y, pre;
    while (scanf("%d%d", &n, &m), n || m)
    {
        for (i = 0, len = 0; i < n; i++)
        {
            for (j = 0; j <= i; j++)
            {
                scanf("%d", &map[i][j]);
                if (map[i][j] == 0)
                {
                    e[len][0] = i, e[len++][1] = j;
                }
            }
            map[i][j] = -1;
        }
        for (i = 0, max = -100; i < len; i++)
        {
            x = e[i][0], y = e[i][1];
            map[x][y] = m;
            set();
            pre = work();
            max = Max(max, pre);
            map[x][y] = 0;
        }
        printf("%d\n", max);
    }
    return 0;
}

火碳黑 2010-05-06 23:00 发表评论

pku 1157 LITTLE SHOP OF FLOWERS——经典dp

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

LITTLE SHOP OF FLOWERS

Description

You want to arrange the window of your flower shop in a most pleasant way. You have F bunches of flowers, each being of a different kind, and at least as many vases ordered in a row. The vases are glued onto the shelf and are numbered consecutively 1 through V, where V is the number of vases, from left to right so that the vase 1 is the leftmost, and the vase V is the rightmost vase. The bunches are moveable and are uniquely identified by integers between 1 and F. These id-numbers have a significance: They determine the required order of appearance of the flower bunches in the row of vases so that the bunch i must be in a vase to the left of the vase containing bunch j whenever i < j. Suppose, for example, you have bunch of azaleas (id-number=1), a bunch of begonias (id-number=2) and a bunch of carnations (id-number=3). Now, all the bunches must be put into the vases keeping their id-numbers in order. The bunch of azaleas must be in a vase to the left of begonias, and the bunch of begonias must be in a vase to the left of carnations. If there are more vases than bunches of flowers then the excess will be left empty. A vase can hold only one bunch of flowers.

Each vase has a distinct characteristic (just like flowers do). Hence, putting a bunch of flowers in a vase results in a certain aesthetic value, expressed by an integer. The aesthetic values are presented in a table as shown below. Leaving a vase empty has an aesthetic value of 0.

		V A S E S
		1	2	3	4	5
Bunches	1 (azaleas)	7	23	-5	-24	16
	2 (begonias)	5	21	-4	10	23
	3 (carnations)	-21	5	-4	-20	20

According to the table, azaleas, for example, would look great in vase 2, but they would look awful in vase 4.

To achieve the most pleasant effect you have to maximize the sum of aesthetic values for the arrangement while keeping the required ordering of the flowers. If more than one arrangement has the maximal sum value, any one of them will be acceptable. You have to produce exactly one arrangement.

Input

The first line contains two numbers: F, V.
The following F lines: Each of these lines contains V integers, so that A_ij is given as the j^th number on the (i+1)^st line of the input file.

1 <= F <= 100 where F is the number of the bunches of flowers. The bunches are numbered 1 through F.
F <= V <= 100 where V is the number of vases.
-50 <= Aij <= 50 where Aij is the aesthetic value obtained by putting the flower bunch i into the vase j.

Output

The first line will contain the sum of aesthetic values for your arrangement.

Sample Input

3 5
7 23 -5 -24 16
5 21 -4 10 23
-21 5 -4 -20 20

Sample Output

题意：选花插瓶，瓶按直线排放，后一种花要插在前一种花后面。（不懂就看看原题意思比较好）
代码：

#include<stdio.h>
#define Max(a, b) a > b ? a : b
#define maxn 101
int ans[maxn][maxn], m[maxn][maxn];
//前i朵花插在前j个花瓶所得的最大值，i <= j，
//ans[i][j] 就是从ans[i-1][i-1 ……j-1]里的最大值加上m[i][j]，然后再ans[i][j] = Max(ans[i][i]……ans[i][j]),
//但在ans[i][i]时只有一种状态，ans[i][i] = ans[i-1][i-1] + m[i][i], 所以后面可直接采取第i种花换不换位置来选择最优解。
int main()
{
    int r, c, t, i, j, a, b;
    while (scanf("%d%d", &r, &c) != EOF)
    {
        t = Max(r, c);
        for (i = 0; i <= t; i++)
        {
            ans[i][0] = ans[0][i] = 0;
        }
        for (i = 1; i <= r; i++)
        {
            b = c - (r - i);
            for (j = 1; j <= c; j++)
            {
                scanf("%d", &m[i][j]);
                if (j == i)
                {
                    ans[i][j] = ans[i-1][j-1] + m[i][j];
                }
                else if(j > i && j <= b)
                {
                    ans[i][j] = Max(ans[i-1][j-1] + m[i][j], ans[i][j-1]);
                }
            }
        }
        printf("%d\n", ans[r][c]);
    }
    system("pause");
    return 0;
}

火碳黑 2010-05-04 14:14 发表评论

pku 2182 Lost Cows——线段树入门题

火碳黑 — Fri, 23 Apr 2010 04:29:00 GMT

Lost Cows

Description

N (2 <= N <= 8,000) cows have unique brands in the range 1..N. In a spectacular display of poor judgment, they visited the neighborhood 'watering hole' and drank a few too many beers before dinner. When it was time to line up for their evening meal, they did not line up in the required ascending numerical order of their brands.

Regrettably, FJ does not have a way to sort them. Furthermore, he's not very good at observing problems. Instead of writing down each cow's brand, he determined a rather silly statistic: For each cow in line, he knows the number of cows that precede that cow in line that do, in fact, have smaller brands than that cow.

Given this data, tell FJ the exact ordering of the cows.

Input

* Line 1: A single integer, N

* Lines 2..N: These N-1 lines describe the number of cows that precede a given cow in line and have brands smaller than that cow. Of course, no cows precede the first cow in line, so she is not listed. Line 2 of the input describes the number of preceding cows whose brands are smaller than the cow in slot #2; line 3 describes the number of preceding cows whose brands are smaller than the cow in slot #3; and so on.

Output

* Lines 1..N: Each of the N lines of output tells the brand of a cow in line. Line #1 of the output tells the brand of the first cow in line; line 2 tells the brand of the second cow; and so on.

Sample Input

Sample Output

2
4
5
#include<stdio.h>
#define maxn 8000
int tree[maxn*3], s[maxn], ans[maxn];
void build(int l, int r, int depth)
{
    tree[depth] = r - l + 1;
    if (l != r)
    {
        int mid = (l + r) >> 1;
        build(l, mid, (depth << 1));
        build(mid + 1, r, (depth << 1) + 1);
    }
}
void find(int l, int r, int index, int num, int depth)
{
    tree[depth]--;
    if (l == r)
    {
        ans[index] = r;
        return;
    }
    else
    {
        int mid = (l + r) >> 1, m = depth << 1;
        if (num <= tree[m])
        {
            find(l, mid, index, num, m);
        }
        else
        {
            num -= tree[m];
            find(mid + 1, r, index, num, m + 1);
        }
    }
}
int main()
{
    int n, i;
    while (scanf("%d", &n) != EOF)
    {
        build(1, n, 1);
        for (i = 2, s[1] = 1; i <= n; i++)
        {
            scanf("%d", &s[i]);
            s[i]++;
        }
        for (i = n; i >= 1; i--)
        {
            find(1, n, i, s[i], 1);
        }
        for (i = 1; i <= n; i++)
        {
            printf("%d\n", ans[i]);
        }
    }
    return 0;
}

3
1
题意：给出每个数所在位置的逆序列个数，求这些数。
用线段树写，一来统计个数，而来可以随时删除已去掉的数，这些操作都是logn。

火碳黑 2010-04-23 12:29 发表评论

2078 Matrix 简单深搜

火碳黑 — Sat, 10 Apr 2010 01:43:00 GMT

Matrix

Description

Given an n*n matrix A, whose entries Ai,j are integer numbers ( 0 <= i < n, 0 <= j < n ). An operation SHIFT at row i ( 0 <= i < n ) will move the integers in the row one position right, and the rightmost integer will wrap around to the leftmost column.

You can do the SHIFT operation at arbitrary row, and as many times as you like. Your task is to minimize
max_{0<=j< n}{Cj|Cj=Σ_0<=i<
nA_i,j}

Input

The input consists of several test cases. The first line of each test case contains an integer n. Each of the following n lines contains n integers, indicating the matrix A. The input is terminated by a single line with an integer −1. You may assume that 1 <= n <= 7 and |A_i,j| < 10⁴.

Output

For each test case, print a line containing the minimum value of the maximum of column sums.

Sample Input

Sample Output

11
15

题意：对任意行可右移任意多次,求列和得最大值，使这个最大值最小。
代码：

#include<stdio.h>
#define maxn 10
#define inf 1 << 29
int w[maxn][maxn], ans[maxn][maxn];
int n, pre;
void find(int depth)
{
    int i, j, max;
    for (i = 0; i < n; i++)
    {
        for (j = 0, max = 0; j < n; j++)
        {
            ans[depth][j] = ans[depth-1][j] + w[depth][(j-i+n)%n];
            //printf("%d ", ans[depth][j]);
            if (max < ans[depth][j])
            {
                max = ans[depth][j];
            }

        }//printf("\n");
        if (n - 1 != depth)
        {
            find(depth+1);
        }
        else
        {
            if (pre > max)
            {
                pre = max;
            }
        }
    }

}
int main()
{
    int i, j;
    while (scanf("%d", &n), n != -1)
    {
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                scanf("%d", &w[i][j]);
            }
        }
        pre = inf;
        if (n > 1)
        {
            for (i = 0; i < n; i++)
            {
                ans[0][i] = w[0][i];
            }
            find(1);
        }
        else
        {
            pre = w[0][0];
        }
        printf("%d\n", pre);
    }
    return 0;
}

火碳黑 2010-04-10 09:43 发表评论

pku 1408 Fishnet

火碳黑 — Mon, 29 Mar 2010 14:57:00 GMT

Fishnet

Description

A fisherman named Etadokah awoke in a very small island. He could see calm, beautiful and blue sea around the island. The previous night he had encountered a terrible storm and had reached this uninhabited island. Some wrecks of his ship were spread around him. He found a square wood-frame and a long thread among the wrecks. He had to survive in this island until someone came and saved him.

In order to catch fish, he began to make a kind of fishnet by cutting the long thread into short threads and fixing them at pegs on the square wood-frame. He wanted to know the sizes of the meshes of the fishnet to see whether he could catch small fish as well as large ones.

The wood frame is perfectly square with four thin edges on meter long: a bottom edge, a top edge, a left edge, and a right edge. There are n pegs on each edge, and thus there are 4n pegs in total. The positions of pegs are represented by their (x,y)-coordinates. Those of an example case with n=2 are depicted in figures below. The position of the ith peg on the bottom edge is represented by (ai,0). That on the top edge, on the left edge and on the right edge are represented by (bi,1), (0,ci) and (1,di), respectively. The long thread is cut into 2n threads with appropriate lengths. The threads are strained between (ai,0) and (bi,1),and between (0,ci) and (1,di) (i=1,...,n).

You should write a program that reports the size of the largest mesh among the (n+1)2 meshes of the fishnet made by fixing the threads at the pegs. You may assume that the thread he found is long enough to make the fishnet and the wood-frame is thin enough for neglecting its thickness.

Input

The input consists of multiple sub-problems followed by a line containing a zero that indicates the end of input. Each sub-problem is given in the following format.
n
a1 a2 ... an
b1 b2 ... bn
c1 c2 ... cn
d1 d2 ... dn
you may assume 0 < n <= 30, 0 < ai,bi,ci,di < 1

Output

For each sub-problem, the size of the largest mesh should be printed followed by a new line. Each value should be represented by 6 digits after the decimal point, and it may not have an error greater than 0.000001.

Sample Input

2
0.2000000 0.6000000
0.3000000 0.8000000
0.1000000 0.5000000
0.5000000 0.6000000
2
0.3333330 0.6666670
0.3333330 0.6666670
0.3333330 0.6666670
0.3333330 0.6666670
4
0.2000000 0.4000000 0.6000000 0.8000000
0.1000000 0.5000000 0.6000000 0.9000000
0.2000000 0.4000000 0.6000000 0.8000000
0.1000000 0.5000000 0.6000000 0.9000000
2
0.5138701 0.9476283
0.1717362 0.1757412
0.3086521 0.7022313
0.2264312 0.5345343
1
0.4000000
0.6000000
0.3000000
0.5000000
0

Sample Output

题意：求出被网丝切出来的四边形的最大面积
代码：

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#define maxn 40
struct point
{
    double x, y;
};
point a[maxn], b[maxn], c[maxn], d[maxn], map[maxn][maxn];
void read(int n)
{
    int j;
    for (j = 1; j <= n; j++)
    {
        scanf("%lf", &a[j].x);
        a[j].y = 0;
    }
    for (j = 1; j <= n; j++)
    {
        scanf("%lf", &b[j].x);
        b[j].y = 1;
    }
    for (j = 1; j <= n; j++)
    {
        scanf("%lf", &c[j].y);
        c[j].x = 0;
    }
    for (j = 1; j <= n; j++)
    {
        scanf("%lf", &d[j].y);
        d[j].x = 1;
    }
    for (j = 1; j <= n/2; j++)
    {
        double temp;
        temp = c[j].y;
        c[j].y = c[n+1-j].y;
        c[n+1-j].y = temp;
        temp = d[j].y;
        d[j].y = d[n+1-j].y;
        d[n+1-j].y = temp;
    }
}
point GetCrossPoint(point p1, point p2, point q1, point q2)//获取交点
{
    point crossPoint;
    double tempLeft,tempRight;
    tempLeft = 1.0 * (q2.x - q1.x) * (p1.y - p2.y) - (p2.x - p1.x) * (q1.y - q2.y);
    tempRight = 1.0 * (p1.y - q1.y) * (p2.x - p1.x) * (q2.x - q1.x) + q1.x * (q2.y - q1.y) * (p2.x - p1.x) - p1.x * (p2.y - p1.y) * (q2.x - q1.x);
    crossPoint.x = 1.0 * tempRight / tempLeft;
    tempLeft = 1.0 * (p1.x - p2.x) * (q2.y - q1.y) - (p2.y - p1.y) * (q1.x - q2.x);
    tempRight = 1.0 * p2.y * (p1.x - p2.x) * (q2.y - q1.y) + (q2.x- p2.x) * (q2.y - q1.y) * (p1.y - p2.y) - q2.y * (q1.x - q2.x) * (p2.y - p1.y);
    crossPoint.y = 1.0 * tempRight / tempLeft;
    return crossPoint;
}
//double dis(point p1, point p2)
//{
//    return sqrt(1.0 * (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y)) ;
//}
//double ss(double a, double b, double c)
//{
//    double p = 1.0 * (a + b + c) / 2;
//    return p = sqrt(1.0 * p * (p-a) * (p-b) * (p-c));
//}
//double squal(point pp1, point pp2, point pp3, point pp4)
//{
//    double a, b, c, d, e;
//    a = dis(pp1, pp2);
//    b = dis(pp2, pp4);
//    d = dis(pp4, pp3);
//    c = dis(pp3, pp1);
//    e = dis(pp1, pp4);
//    return 1.0 * (ss(a, b, e) + ss(d, c, e));
//}
double cj(point p1, point p2)
{
    return 1.0 * p1.x * p2.y - p1.y * p2.x;
}
double squal(point p1, point p2, point p3, point p4)
{
    double sum =  0.5 * (cj(p1, p2) + cj(p2, p4) + cj(p4, p3) + cj(p3, p1));
    if (sum < 0)
    {
        return -sum;
    }
    return sum;
}
//double squal(point p1, point p2, point p3, point p4)
//{
//    double x1, y1, x2, y2, a, b, sum;
//    //----------------------------------叉积算面积，算出来为三角形的两倍
//    x1 = p1.x - p3.x, y1 = p1.y - p3.y;
//    x2 = p4.x - p3.x, y2 = p4.y - p3.y;
//    a = 1.0 * x1 * y2 - y1 * x2;
//    if (a < 0)
//    {
//        a = -a;
//    }
//    //-----------------------------------
//    x1 = p1.x - p2.x, y1 = p1.y - p2.y;
//    x2 = p4.x - p2.x, y2 = p4.y - p2.y;
//    b = 1.0 * x1 * y2 - y1 * x2;
//    if (b < 0)
//    {
//        b = -b;
//    }
//    return sum = 1.0 * (a + b) / 2;
//}
double deal(int n)
{
    int i, j;
    double max, pre;
    point ans;
    map[0][0].x = 0, map[0][0].y = 1;
    map[n+1][0].x = 0, map[n+1][0].y = 0;
    map[0][n+1].x = 1, map[0][n+1].y = 1;
    map[n+1][n+1].x = 1, map[n+1][n+1].y = 0;
    for (i = 1; i <= n; i++)
    {
        map[0][i] = b[i];
        map[n+1][i] = a[i];
        map[i][0] = c[i];
        map[i][n+1] = d[i];
    }

    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            map[i][j] = GetCrossPoint(c[i], d[i], b[j], a[j]);
        }
    }
    for (i = 0, max = 0; i <= n; i++)
    {
        for (j = 0; j <= n; j++)
        {
            pre = squal(map[i][j], map[i][j+1], map[i+1][j], map[i+1][j+1]);
            if (pre > max)
            {
                max = pre;
            }
        }
    }
    return max;
}
int main()
{
    int n;
    double ans;
    while (scanf("%d", &n), n)
    {
        read(n);
        ans = deal(n);
        printf("%.6lf\n", ans);
    }
    system("pause");
    return 0;
}

火碳黑 2010-03-29 22:57 发表评论

pku 2607 Fire Station

火碳黑 — Mon, 29 Mar 2010 12:12:00 GMT

Fire Station

Description

A city is served by a number of fire stations. Some residents have complained that the distance from their houses to the nearest station is too far, so a new station is to be built. You are to choose the location of the fire station so as to reduce the distance to the nearest station from the houses of the disgruntled residents.
The city has up to 500 intersections, connected by road segments of various lengths. No more than 20 road segments intersect at a given intersection. The location of houses and firestations alike are considered to be at intersections (the travel distance from the intersection to the actual building can be discounted). Furthermore, we assume that there is at least one house associated with every intersection. There may be more than one firestation per intersection.

Input

The first line of input contains two positive integers: f,the number of existing fire stations (f <= 100) and i, the number of intersections (i <= 500). The intersections are numbered from 1 to i consecutively. f lines follow; each contains the intersection number at which an existing fire station is found. A number of lines follow, each containing three positive integers: the number of an intersection, the number of a different intersection, and the length of the road segment connecting the intersections. All road segments are two-way (at least as far as fire engines are concerned), and there will exist a route between any pair of intersections.

Output

You are to output a single integer: the lowest intersection number at which a new fire station should be built so as to minimize the maximum distance from any intersection to the nearest fire station.

Sample Input

Sample Output

题目：寻找一个站点建立救火站，使得所有点到救火站的最短距的最大值能更小。
代码：

#include<stdio.h>
#define maxn 511
#define inf 1 << 29
#define Max(a, b) a > b ? a : b
#define Min(a, b) a < b ? a : b
int map[maxn][maxn];
int p[maxn];
int sh[maxn];
void set(int n)
{
    int i, j;
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            map[i][j] = inf;
        }
        map[i][i] = 0;
    }
}
void floyd(int n)
{
    int i, j, k;
    for (k = 1; k <= n; k++)
    {
        for (i = 1; i <= n; i++)
        {
            if (i != k)
            {
                for (j = 1; j <= n; j++)
                {
                    if (j != i && j != k && map[i][j] > map[i][k] + map[k][j])
                    {
                        map[i][j] = map[i][k] + map[k][j];
                    }
                }
            }
        }
    }
}
int deal(int n, int f)
{
    int min, max, pre;
    int i, j, ans;
    for (i = 1, pre = 0; i <= n; i++)//求出每个顶点到现有的最近救火站距离保存于sh
    {
        for (j = 0, min = inf; j < f; j++)
        {
            min = Min(min, map[i][p[j]]);
        }
        sh[i] = min;
        pre = Max(pre, min);//挑出最短距地最大值
    }
    for (i = 1, ans = i; i <= n; i++)//枚举每个节点
    {
        for (j = 1, max = 0; j <= n; j++)
        {
            if (map[i][j] < sh[j])//如果j到i的距离更短
            {
                max = Max(max, map[i][j]);
            }
            else
            {
                max = Max(max, sh[j]);
            }
        }
        if (pre > max)//如果最大值被更新，则表示在i建立一个救火站能是最短距地最大值更小
        {
            ans = i;
            pre = max;
        }
    }
    return ans;
}

int main()
{
    int n, i, f, u, v;
    int w;
    scanf("%d%d", &f, &n);
    {
        set(n);
        for (i = 0; i < f; i++)
        {
            scanf("%d", &p[i]);
        }
        while (scanf("%d%d%d", &u, &v, &w) != EOF)
        {
            map[u][v] = w, map[v][u] = w;
        }
        floyd(n);
        printf("%d\n", deal(n, f));
    }
    system("pause");
    return 0;
}

火碳黑 2010-03-29 20:12 发表评论

pku 1406 Starship Hakodate-maru

火碳黑 — Sat, 27 Mar 2010 07:31:00 GMT

Starship Hakodate-maru

Description

The surveyor starship Hakodate-maru is famous for her two fuel containers with unbounded capacities. They told the same type of atomic fuel balls.

There, however, is an inconvenience. The shapes of the fuel containers #1 and #2 are always cubic and regular tetrahedral respectively. Both of the fuel containers should be either empty or filled according to their shapes. Otherwise, the fuel balls become extremely unstable and may explode in the fuel containers. Thus, the number of fuel balls for the container #1 should be a cubic number( n^3 for some n=0,1,2,3,...) and that for the container #2 should be a tetrahedral number ( n(n+1)(n+2)/6 for some n=0,1,2,3,...).

Hakodate-maru is now at the star base Goryokaku preparing for the next mission to create a precise and detailed chart of stars and interstellar matters. Both of the fuel containers are now empty. Commander Parus of Goryokaku will soon send a message to Captain Future of Hakodate-maru on how many fuel balls Goryokaku can supply. Captain Future should quickly answer to Commander Parus on how many fuel balls she requests before her ship leaves Goryokaku. Of course, Captain Future and her officers want as many fuel balls as possible.

For example, consider the case Commander Parus offers 151200 fuel balls. If only the fuel container #1 were available ( i.e. if the fuel container #2 were unavailable), at most 148877 fuel balls could be put into the fuel container since 148877=53*53*53< 151200< 54*54*54. If only the fuel container #2 were available, at most 147440 fuel balls could be put into the fuel container since 147440=95*96*97 / 6 < 151200 < 96*97*98 / 6. Using both of the fuel containers #1 and #2, 151200 fuel balls can be put into the fuel containers since 151200 = 39*39*39+81*82*83 / 6. In this case, Captain Future's answer should be "151200"

Commander Parus's offer cannot be greater than 151200 because of the capacity of the fuel storages of Goryokaku. Captain Future and her officers know that well.

You are a fuel engineer assigned to Hakodate-maru. Your duty today is to help Captain Future with calculating the number of fuel balls she should request.

Input

The input is a sequence of at most 1024 positive integers. Each line contains a single integer. The sequence is followed by a zero, which indicate the end of data and should not be treated as input. You may assume that none of the input integers is greater than 151200.

Output

The output is composed of lines, each containing a single integer. Each output integer should be the greatest integer that is the sum of a nonnegative cubic number and a nonnegative tetrahedral number and that is not greater than the corresponding input number. No other characters should be appear in the output.

Sample Input

Sample Output

题意：对于给出的n，找x和y使得x*x*x + y * (y+1) * (y+2) <= n(如果不等，取最靠近n的值)

代码：

#include<stdio.h>
__int64 x, y, z;
__int64 cubic(__int64 num)
{
    __int64 l = 1, h = num, m;
    while (l <= h)
    {
        m = (l + h ) / 2;
        x = m * m * m;
        if (x > num)
        {
            h = m - 1;
        }
        else if (x < num)
        {
            l = m + 1;
        }
        else return m;
    }
    return l - 1;
}
__int64 tetrahedral(__int64 num)
{
    __int64 l = 1, h = num, m;
    while (l <= h)
    {
        m = (l + h ) / 2;
        y = m * (m + 1) * (m + 2) / 6;
        if (y > num)
        {
            h = m - 1;
        }
        else if (y < num)
        {
            l = m + 1;
        }
        else return m;
    }
    return l - 1;
}
__int64 both(__int64 a, __int64 b, __int64 num)
{
    __int64 i, j, z, pre = a;
    if (pre < b)
    {
        pre = b;
    }
    for (i = b; i >= 0; i--)
    {
        for (j = a; j >= 0; j--)
        {
            z = j * j * j + i * (i + 1) * (i + 2) / 6;
            if (z == num)
            {
                return z;
            }
            else if (z < num)
            {
                if (z > pre)
                {
                    pre = z;
                }
                else if (j == a)//因为i是单调递减，而j每次循环初始化为最大，但j最大时仍有z
                {
                    return pre;
                }

            }

        }
    }
    return pre;
}
int main()
{
    __int64 n, a, b, c;
    while (scanf("%I64d", &n), n)
    {
        if(a = cubic(n), x == n)
        {
            printf("%I64d\n", x);
        }
        else if(b = tetrahedral(n), y == n)
        {
            printf("%I64d\n", y);
        }
        else
        {
            c = both(a, b, n);
            printf("%I64d\n", c);
        }
        //printf("%I64d %I64d\n", a, b);
    }
    system("pause");
    return 0;
}

火碳黑 2010-03-27 15:31 发表评论

pku 1405 Heritage

火碳黑 — Fri, 26 Mar 2010 06:44:00 GMT

Heritage

Description

Your rich uncle died recently, and the heritage needs to be divided among your relatives and the church (your uncle insisted in his will that the church must get something). There are N relatives (N <= 18) that were mentioned in the will. They are sorted in descending order according to their importance (the first one is the most important). Since you are the computer scientist in the family, your relatives asked you to help them. They need help, because there are some blanks in the will left to be filled. Here is how the will looks:

Relative #1 will get 1 / ... of the whole heritage,
Relative #2 will get 1 / ... of the whole heritage,
---------------------- ...
Relative #n will get 1 / ... of the whole heritage.

The logical desire of the relatives is to fill the blanks in such way that the uncle's will is preserved (i.e the fractions are non-ascending and the church gets something) and the amount of heritage left for the church is minimized.

Input

The only line of input contains the single integer N (1 <= N <= 18).

Output

Output the numbers that the blanks need to be filled (on separate lines), so that the heritage left for the church is minimized.

Sample Input

Sample Output

2
3

题意：将一份财产分成n份，1/x1, 1/x2, 1/x3, ...,1/xn.使得x1>x2>x3>...>xn,让教堂分得的财产最少. xn = x1 * x2 * ...*xn-1 + 1.
如果前k个分剩下1/c,因为1/c>1/(c+1)>1/(c+2)>...所以下一个拿1/(c+1),剩下1/(c * (c+1)).
代码：

#include<stdio.h>
#include<stdlib.h>
#define inf 1000000000
#define maxn 100000
int len1, len2, len3, len[18];
__int64 a[maxn], b[maxn], ans[maxn], res[18][maxn];
void setAns()
{
    for (int i = 0; i < len3; i++)
    {
        ans[i] = 0;
    }
}
void copy()
{
    for (int i = 0; i < len3; i++)
    {
        a[i] = ans[i];
    }
    len1 = len3;
}
void multiply()//inf进制乘法
{
    int i, j;
    setAns();
    for (i = 0; i < len2; i++)
    {
        for (j = 0; j < len1; j++)
        {
            ans[i+j] += a[j] * b[i];
            ans[i+j+1] += ans[i+j] / inf;
            if (ans[i+j+1] && len3 <= i + j + 1)
            {
                len3 = i + j + 2;
            }
            else if (len3 <= i + j)
            {
                len3 = i + j + 1;
            }
            ans[i+j] %= inf;
        }
    }
}
void plus()//让a+1
{
    int r;
    for (len2 = 0, r = 1; len2 < len1; len2++)
    {
        r += a[len2];
        if (r >= inf)
        {
            b[len2] = r - inf;
            r = 1;
        }
        else
        {
            b[len2] = r;
            r = 0;
        }
    }
    if (r)
    {
        b[len2++] = r;
    }
}
int main()
{
    int i, j, n;
    scanf("%d", &n);
    a[0] = 2;
    len1 = 1;
    printf("2\n");
    for (i = 2; i <= n; i++)
    {
        plus();
        printf("%I64d", b[len2-1]);
        for (j = len2 - 2; j >= 0; j--)
        {
            printf("%.9I64d", b[j]);//输出占9为，前面如果不足则补零
        }printf("\n");
        if (i < n)
        {
            multiply();
            copy();
        }
    }
    //system("pause");
    return 0;
}

火碳黑 2010-03-26 14:44 发表评论

pku 3250 Bad Hair Day——所谓的DP

火碳黑 — Tue, 15 Dec 2009 03:05:00 GMT

Bad Hair Day

Description

Some of Farmer John's N cows (1 ≤ N ≤ 80,000) are having a bad hair day! Since each cow is self-conscious about her messy hairstyle, FJ wants to count the number of other cows that can see the top of other cows' heads.

Each cow i has a specified height h_i (1 ≤ h_i≤ 1,000,000,000) and is standing in a line of cows all facing east (to the right in our diagrams). Therefore, cow i can see the tops of the heads of cows in front of her (namely cows i+1, i+2, and so on), for as long as these cows are strictly shorter than cow i.

Consider this example:

        =
=       =
=   -   =         Cows facing right -->
=   =   =
= - = = =
= = = = = =
1 2 3 4 5 6

Cow#1 can see the hairstyle of cows #2, 3, 4
Cow#2 can see no cow's hairstyle
Cow#3 can see the hairstyle of cow #4
Cow#4 can see no cow's hairstyle
Cow#5 can see the hairstyle of cow 6
Cow#6 can see no cows at all!

Let c_i denote the number of cows whose hairstyle is visible from cow i; please compute the sum of c₁ through c_N.For this example, the desired is answer 3 + 0 + 1 + 0 + 1 + 0 = 5.

Input

Line 1: The number of cows, N.
Lines 2..N+1: Line i+1 contains a single integer that is the height of cow i.

Output

Line 1: A single integer that is the sum of c₁ through c_N.

Sample Input

Sample Output

5
题意：
给出的序列中，如果i < k < j 而且 h[k] < h[i] < h[j]，对i找出i到j区间比h[i]小的数的个数s[i]。然后对每个i求和。

#include<stdio.h>
#define maxn 80001
int h[maxn], next[maxn], s[maxn];
int main()
{
    int i, k, n;
    unsigned sum;
    while (scanf("%d", &n) != EOF)
    {
        for (i = 0; i < n; i++)
        {
            scanf("%d", &h[i]);
            s[i] = 0;
        }
        for (i = n - 1, sum = 0; i >= 0; i--)
        {
            k = i + 1;
            for (; k < n && h[k] < h[i]; k = next[k])//每一次都把寻找比h[i]大的h[k]。
            {
                s[i] += s[k] + 1;
            }
            next[i] = k;
            sum += s[i];
        }
        printf("%u\n", sum);
    }
    return 0;
}

火碳黑 2009-12-15 11:05 发表评论