一道大「水题」 题解

一道大水题

时间限制: 1000ms

空间限制: 256000kB

题目描述

[题目描述]

有 $n$ 个点，第 $i$ 个点到第 $j$ 个点有边当且仅当j是i的倍数且 $j/i$ 为质数。（边是单向的）

给出 $q$ 组询问，每次询问从第 $1$ 个点走到第 $x$ 个点的方案数，对 $1e9+7$ 取模。

[输入格式]

第一行两个正整数 $n$ , $q$。

接下来 $q$ 行每行一个正整数 $x$ 。

[输出格式]

$q$ 行，每行一个正整数。

[输入样例]

10 5

4

6

8

9

10

[输出样例]

1

2

1

1

2

[数据范围]

对于60%的数据， $n<=1000,q<=1000$ 。

对于100%的数据， $n<=500000,q<=500000$ 。

---

题目本来就很清真，直接复制一下(滑稽 :

有 $n$ 个点，第 $i$ 个点到第 $j$ 个点有边当且仅当 $j$ 是 $i$ 的倍数且 $j/i$ 为质数。（边是单向的）
给出 $q$ 组询问，每次询问从第 $1$ 个点走到第 $x$ 个点的方案数，对 $1e9+7$ 取模。

解法一 (较复杂) ：

一眼看是图论，先进行埃氏筛,建图

for (int i = 2 ; i <= n ; i ++)
    if (f [i] == 0)
        for (int j = i * i ; j <= n ; j += i)
            f [j] = 1 ;
for (int i = 2 ; i <= n ; i ++)
    if (f [i] == 0)
        for (int j = 1 ; j <= n / i ; j ++)
            a [j].push_back (j * i) ;

接下来从 $1$ 开始进行拓扑排序，然后进行dp

dp状态就是节点加所有的父亲的状态

dp [sx] += dp [fx] ;  // sx为fx的儿子节点

(记得要 dp[1] = 1 ; )

接下来输入什么就输出dp [x]

(记得要取模)

AC代码：

#include <bits/stdc++.h>
#define int long long
#pragma G++ optimize (2)
#pragma G++ optimize (3)
using namespace std ;
int n , T , f [500010] , x , rd [500010] , dp [500010] ;
vector <int> a [500010] ;
queue <int> q ;
void topo () {
	int fx , sx ;
	q.push (1) ; dp [1] = 1 ;
	while (! q.empty ()) {
		fx = q.front () ; q.pop () ;
		for (int i = 0 ; i < a [fx].size () ; i ++) {
			sx = a [fx] [i] ;
			rd [sx] -- ; dp [sx] += dp [fx] ;
			if (rd [sx] == 0)  q.push (sx) ;
		}
	}
}
main () {
	ios::sync_with_stdio (false) ;
	cin.tie (NULL) ; cout.tie (NULL) ;
	cin >> n >> T ;
	for (int i = 2 ; i <= n ; i ++)
		if (f [i] == 0)
			for (int j = i * i ; j <= n ; j += i)
				f [j] = 1 ;
	for (int i = 2 ; i <= n ; i ++)
		if (f [i] == 0)
			for (int j = 1 ; j <= n / i ; j ++)
				a [j].push_back (j * i) , rd [j * i] ++ ;
	topo () ;
	while (T --) {
		cin >> x ;
		cout << dp [x] << "\n" ; 
	}
	return 0 ;
}

---

解法二 (较为简单)：

其实用不着建图，可以直接进行dp

枚举 $i$ 和 $j$ ，判断 $j/i$ 是否为素数，是的话dp，同上

关键代码：

for (int i = 1 ; i <= n ; i ++)
    for (int j = i * 2 ; j <= n ; j += i)
        if (is_prime (j / i))
            dp [j] = (dp [j] + dp[i]) % mod ;