ZOJ 3644 Kitty's Game（数论+DP）

Description

Kitty is a little cat. She is crazy about a game recently.

There arenscenes in the game(mark from 1 ton). Each scene has a numberp_i. Kitty's score will become least_common_multiple(x,p_i) when Kitty enter thei^thscene.xis the score that Kitty had previous. Notice that Kitty will become mad If she go to another scene but the score didn't change.

Kitty is staying in the first scene now(withp₁score). Please find out how many paths which can arrive at then^thscene and haskscores at there. Of course, you can't make Kitty mad.

We regard two paths different if and only if the edge sequence is different.

Input

There are multiple test cases. For each test case:

The first line contains three integern(2 ≤n≤ 2000),m(2 ≤m≤ 20000),k(2 ≤k≤ 10⁶). Then followed bymlines. Each line contains two integeru,v(1 ≤u,v≤ n, u ≠ v) indicate we can go tov^thscene fromu^thscene directly. The last line of each case contains n integerp_i(1 ≤p_i≤ 10⁶).

Process to the end of input.

Output

One line for each case. The number of paths module 1000000007.

题目大意：有n个点m条无向边，每个点有一个分值p[i]，设x为当前分值，每经过一个点，分值就会变成LCM(x, p[i])，若经过一个点的时候分值没有变化，那么这个点不能走。现在要从点1走到点n，要得到k的分值，问有多少种方法。

思路：首先走的每一步都必须是k的约数（不然到达终点的时候不可能得到k），那么走到每个点上至多有sum{k的约数}的分值，把k离散化，k最多有2*sqrt(k)个约数，即2000个。然后开始DP，dp[i][j]表示走到第i个点，得到分值j（离散值），并且能走到终点的方案数。然后记忆化搜索即可。原图有环也无所谓，因为分值每走一步必须要变化，而且只会越来越大，不会走出环来。

代码（120MS）：

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <map>
 using namespace std;

 typedef long long LL;

 const int MAXN = ;
 const int MAXE = ;
 const int MOD = ;

 map<int, int> mp;

 int n, m, k, ecnt;
 int head[MAXN];
 int to[MAXE], next[MAXE];
 int dp[MAXN][MAXN], val[MAXN];

 void init() {
     memset(head, , sizeof(head));
     ecnt = ;
 }

 inline void add_edge(int u, int v) {
     to[ecnt] = v; next[ecnt] = head[u]; head[u] = ecnt++;
 }

 LL gcd(LL a, LL b) {
     return b ? gcd(b, a % b) : a;
 }

 LL lcm(LL a, LL b) {
     return a * b / gcd(a, b);
 }

 inline void get_app() {
     mp.clear();
     int cnt = ;
     for(int i = ; i * i <= k; ++i) {
         if(k % i != ) continue;
         mp[i] = ++cnt;
         if(i * i != k) mp[k / i] = ++cnt;
     }
 }

 int dfs(int u, LL x) {
     if(u == n && x == k) return ;
     int now = mp[x];
     if(dp[u][now] != -) return dp[u][now];
     dp[u][now] = ;
     for(int p = head[u]; p; p = next[p]) {
         int &v = to[p];
         if(k % val[v] != ) continue;
         LL tmp = lcm(x, val[v]);
         if(tmp == x || tmp > k) continue;
         dp[u][now] = (dp[u][now] + dfs(v, tmp)) % MOD;
     }
     return dp[u][now];
 }

 int main() {
     while(scanf("%d%d%d", &n, &m, &k) != EOF) {
         init();
         while(m--) {
             int u, v;
             scanf("%d%d", &u, &v);
             add_edge(u, v);
         }
         for(int i = ; i <= n; ++i) scanf("%d", &val[i]);
         get_app();
         memset(dp, , sizeof(dp));
         int ans = (k % val[]) ?  : dfs(, val[]);
         cout<<ans<<endl;
     }
 }