C++博客-夜幻梦回-文章分类-最近公共祖先||rmq问题

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