咕咕咕的冲动如此强烈x
T1x：
看完题目想了想，感觉把gcd不为1的强行放在一组，看作一个连通块，最后考虑连通块之间的组合方式就可以了。
然后维护这个连通块可以写并查集可以连边跑dfs怎么着都行…
然而我在处理数字分解质因数这里T掉了，原因是一个很显然的优化写法我基本没怎么写过。线性筛的时候记录每个数是被哪个质数标记过的，分解一个数的时候直接处理记录下来的质数就可以。
#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
int n,t;
long long mod=1e9+7,ans,sum;
int num[2000010],pri[2000010],cnt,vis[2000010],pre[2000010];
int fa[200010];
void work(){
for(int i=2;i<=1000000;i++){
if(!vis[i]){
pri[++cnt]=i;
pre[i]=i;
}
for(int j=1;j<=cnt&&i*pri[j]<=1000000;j++){
vis[i*pri[j]]=1;
pre[i*pri[j]]=pri[j];
if(i%pri[j]==0)break;
}
}
}
long long ks(long long x,long long k){
long long num=1;
while(k){
if(k&1)num=num*x%mod;
x=x*x%mod;
k>>=1;
}
return num;
}
int get(int x){
if(fa[x]==x)return x;
else return fa[x]=get(fa[x]);
}
int main()
{
scanf("%d",&t);
work();
while(t--){
scanf("%d",&n);
sum=n;
for(int i=1;i<=cnt;i++)num[pri[i]]=0;
for(int i=1;i<=n;i++)fa[i]=i;
for(int i=1,x;i<=n;i++){
scanf("%d",&x);
while(x>1){
int y=pre[x];
while(x%y==0)x/=y;
if(!num[y])num[y]=i;
else{
int x1=get(num[y]),x2=get(i);
if(x1!=x2){
fa[x2]=x1;
sum--;
}
num[y]=i;
}
}
}
ans=((ks(2ll,sum)%mod-2)%mod+mod)%mod;
printf("%lld\n",ans);
}
return 0;
}
T2y：
如果直接做的话，显然是从1开始，枚举路径状态，看看这个状态能达到的节点有哪些，并根据这些节点所连的边能达到的点的集合拓展下一位的状态。最后看长度为d的状态有多少个所能到达的点的集合不为空，统计答案。
但是这样要枚举的状态太多了。
于是考虑把路径拆成两部分，对每个点都求一次能达到的路径的答案，存下每个长度为d的一半的路径状态能达到哪些点。可以倒序从n开始求，最后一次求的就正好是1能达到的一半路径的状态。枚举前后两半的路径状态，若两者存在交集，即两半路径存在可以相连的中间点，那么答案+1。
#include<iostream>
#include<cstdio>
#include<bitset>
using namespace std;
int n,m,d,x1,x2,ans;
bitset<110>sum0[110],sum1[110],f[1<<11],g[1<<11];
//void add(int x,int y,int z){
// ver[++tot]=y;
// Next[tot]=head[x];
// head[x]=tot;
// edge[tot]=z;
//}
int main()
{
scanf("%d%d%d",&n,&m,&d);
x1=d/2,x2=d-x1;
for(int i=1,x,y,z;i<=m;i++){
scanf("%d%d%d",&x,&y,&z);
if(z){
sum1[x][y]=1;
sum1[y][x]=1;
}
else{
sum0[x][y]=1;
sum0[y][x]=1;
}
}
for(int i=n;i>=1;i--){
for(int j=0;j<(1<<11);j++)f[j].reset();
f[1][i]=1;
for(int j=1;j<(1<<x2);j++){
for(int k=1;k<=n;k++){
if(f[j][k]){
f[j<<1]|=sum0[k];
f[j<<1|1]|=sum1[k];
}
}
}
for(int j=0;j<(1<<x2);j++){
g[j][i]=f[(1<<x2)|j].any();
}
}
for(int i=0;i<(1<<x2);i++){
for(int j=0;j<(1<<x1);j++){
if((g[i]&f[(1<<x1)|j]).any())ans++;
}
}
printf("%d\n",ans);
return 0;
}
T3z：
强行模拟这个过程是可以骗到分的，虽然我没骗到多少…
然而正解好像是个更难写的模拟…
首先观察n个任务，发现如果有任务与上一个相同，或者处在上一个任务到下一个任务的路径上，那么这个任务可以忽略不计。简化以后的任务序列就成为了一左一右的过程，每一次线段平移都与上一次走相反方向。
然后可以用链表串起这些有效任务，在询问线段长度小于最小的两个任务间距的时候，答案是一个一次函数。如果有两个任务之间的距离小于询问线段的长度，就合并相连的三个位移，答案还是一个一次函数。
然而并不会写，虽然刚刚重新下载题解的时候好像看到发标程了…
垃圾选手什么都菜，被赶了出来【大雾】
原文地址：https://www.cnblogs.com/chloris/p/11614771.html