HDU 4812 D Tree

点分治,乘法逆元.
题意:给定一棵树(n<=10^5),每个节点都有权值.问是否存在一条从u到v的路径,使得路径上的点的乘积mod上(1e6+3)为给定的k.
解法:树上的点分治,选取一点作为重心,则在当前的树中的答案可能有以下几种情况:
1.u,v在同一棵子树中.
2.u,v在不同的子树中(u,v一定经过重心).
3.u,v中有一点是重心.
第一种情况可以递归解决,2,3种情况需要记录每条从根开始的路径的积.
因为mod的数比较小,可以直接开数组.

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#pragma comment(linker,"/STACK:102400000,102400000")

const int MAXN = 100005;
const int MOD = 1000003;
typedef long long LL;

struct node
{
    int to, next;
};

int n, k;
node edge[MAXN << 1];
int head[MAXN], cnt_edge, size[MAXN], ans[2], d[MAXN];
bool is_centre[MAXN];
int cnt_path, path_val[MAXN], path_id[MAXN];
int tap, flag[MOD], pos[MOD];

void update_ans(int x, int y)
{
    if (x > y)  swap(x, y);
    if (ans[0] == -1) {
        ans[0] = x, ans[1] = y;
        return;
    }
    if (x < ans[0] || (x == ans[0] && y < ans[1])) {
        ans[0] = x, ans[1] = y;
    }
}

void init()
{
    cnt_edge = 0;
    memset(head, -1, sizeof(head));
    memset(ans, -1, sizeof(ans));
    memset(is_centre, false, sizeof(is_centre));
    memset(flag, -1, sizeof(flag));
}

void add_edge(int u, int v)
{
    edge[cnt_edge].to = v, edge[cnt_edge].next = head[u], head[u] = cnt_edge ++;
    edge[cnt_edge].to = u, edge[cnt_edge].next = head[v], head[v] = cnt_edge ++;
}

void cal_size(int u, int fu)
{
    size[u] = 1;
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (v == fu || is_centre[v])    continue;
        cal_size(v, u);
        size[u] += size[v];
    }
}

int max_subtree_size, tree_centre;

void cal_centre(int u, int fu, int all)
{
    int val = 0;
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (v == fu || is_centre[v])    continue;
        cal_centre(v, u, all);
        val = max(val, size[v]);
    }
    val = max(val, all - size[u]);
    if (val < max_subtree_size)
    {
        max_subtree_size = val;
        tree_centre = u;
    }
}

void get_tree_centre(int u)
{
    cal_size(u, 0);
    max_subtree_size = size[u], tree_centre = u;
    cal_centre(u, 0, size[u]);
}

int inv[MOD];

void extend_gcd(LL a,LL b,LL &d,LL &x,LL &y)
{
    if(!b)
    {
        d=a;
        x=1;
        y=0;
    }else{
        extend_gcd(b,a%b,d,y,x);
        y-=x*(a/b);
    }
}

LL Inv(LL a,LL n)
{
    LL d,x,y;
    extend_gcd(a, n, d, x, y);
    return d == 1? (x+n)%n:-1;
}

void get_inv()
{
    inv[1] = 1;
    for (int i = 2; i < MOD; ++ i) {
        inv[i] = (int)Inv(i, MOD);
    }
}

void dfs(int u, int fu, long long val)
{
    val = val * d[u] % MOD;
    int tem_val = (int)val;
    path_val[cnt_path] = tem_val, path_id[cnt_path] = u;
    cnt_path ++;
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (v == fu || is_centre[v])    continue;
        dfs(v, u, val);
    }
}

int cur;

void cal_ans(int u, int all)
{
    if (all == 1)   return;
    get_tree_centre(u);
    u = tree_centre;
    is_centre[u] = true;
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (is_centre[v])   continue;
        cnt_path = 0;
        dfs(v, u, 1);
        for (int j = 0; j < cnt_path; ++ j) {
            if (1ll * path_val[j] * d[u] % MOD == k) {
                update_ans(path_id[j], u);
            }
            long long tar = 1ll * k * inv[1ll * path_val[j] * d[u] % MOD] % MOD;
            if (flag[tar] != cur)   continue;
            update_ans(pos[tar], path_id[j]);
        }
        for (int j = 0; j < cnt_path; ++ j) {
            int tem_val = path_val[j];
            if (flag[tem_val] != cur || pos[tem_val] > path_id[j]) {
                flag[tem_val] = cur;
                pos[tem_val] = path_id[j];
            }
        }
    }
    cur ++;
    for (int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if (is_centre[v])   continue;
        cal_ans(v, size[v]);
    }
}

int main()
{
    get_inv();
    while (scanf("%d%d", &n, &k) == 2) {
        init();
        for (int i = 1; i <= n; ++ i) {
            scanf("%d", &d[i]);
        }
        int x, y;
        for (int i = 1; i < n; ++ i) {
            scanf("%d%d", &x, &y);
            add_edge(x, y);
        }
        cal_ans(1, n);
        if (ans[0] != -1)   printf("%d %d\n", ans[0], ans[1]);
        else    puts("No solution");
    }
    return 0;
}