NO.1
Description
对于两个整数k 和m，如果k 和m 的最大公约数为1，则k 和m 互质。给出两个正整
数n 和m(m≤n),定义f(n,m)为1~n！中与m！互质的数的个数。其中n！=1*2*3*..*(n-1)*n。
Task：给定n 和m，要求计算f(n,m)。
Input
本题设多组数据。
输入文件的第一行有一个整数T(1≤T≤100000)，表示有T 组数据。
接下来有T 行，每行两个整数n 和m(2≤n≤100000,2≤m≤n)。
Output
输出文件包含T 行，每行一个整数，表示f(n,m)。
由于答案过大，所以你只要输出f(n,m) mod 131071。
131071 是M17(梅森素数,2^17-1)。
Sample Input
1
3 2
Sample Output
3
数据约定：
对于50%的数据,T=1,2≤N≤10
对于80%的数据，T=1，2≤N≤100000
对于100%的数据，1≤T≤100000，2≤N≤100000
AcFast 友情提示：小心运算溢出，也就是RTE215 错误。。。
思路：欧拉+筛素数
首先，令n=N!，m=M!
∵M<=N
∴m|n，所以问题化为求1-n中与m互质的数的个数，即(n/m)*phi(m)，其正确性是显然的。
如果一个数x< m且和m互质，即gcd(x,m)=1，那么gcd(x+km,m)=1，假设x+km和m不互质，那么一定存在一个m的因数y，使得y也是x+km的因数，即能写成y(x/y+km/y)，但是x中没有y这个因子，
∴假设不成立
∴gcd(x+km,m)=1，对于每一个小于m的和m互质的数，都能用这个式子退出剩下的大于m小于等于n且和m互质的数，于是我们得到ans=(n/m)phi(m)，这样是否包含了所有的答案呢？
可以知道对于任意一个与m互质的数，减去km一定能得到m以内的一个和m互质的数，因此上式包含了所有的符合要求的数
由于M!是阶乘，所以phi(i)=M!(1-1/p1)(1-1/p2)…(1-1/pk)，1到pk是小于等于M的所有素数，O(MloglogM)筛出，约去M!得ans=N!(1-1/p1)(1-1/p2)…(1-1/pk)，所有的N!都可以在O(N)的预处理求出，因为要modR，所以需要求p1到pk的逆元，方程inv[i]=(M-M/i)* inv[M%i]%M，O(N)的预处理。
我们观察式子：ans=N!(1-p1/1)(1-p2/1)…(1-pk/1)，对于不同的询问，只有N!和k不同，既然能够预处理N!，何不预处理后面的乘积？进行O(M)的预处理，每次回答的复杂度降为O(1)。
代码如下：
#include <cstdio>
#include <bitset>
using namespace std;
const int N=100005;
const int mod=131071;
bitset<N> zs;
long long jc[N],ans[N],times[N];
void ycl()
{
int i,j;
zs.set();
for (i=2;i<N;i++) if (zs[i]) for (j=i+i;j<N;j+=i) zs[j]=false;
jc[0]=1;
for (i=1;i<N;i++) jc[i]=jc[i-1]*i %mod;
times[1]=1;
for (i=2;i<N;i++)
{
if(i>=mod) break;
times[i]=(mod-mod/i)*times[mod%i]%mod;
}
ans[1]=1;
for (i=2;i<N;i++)
if (zs[i])
{
ans[i]=ans[i-1]*(i-1)% mod;
ans[i]=ans[i]*times[i%mod]% mod;
}
else ans[i]=ans[i-1];
}
int main ()
{
int T;
scanf("%d",&T);
ycl();
int m,n;
while (T--)
{
scanf("%d%d",&n,&m);
long long answer=jc[n]*ans[m]%mod;
printf("%lld\n",answer);
}
return 0;
}NO.2
Description
给你一个N*M 的矩阵，矩阵里面的元素要么是正数，要么是负数，它们的绝对值不大
于10000。现在你可以对矩阵进行两种操作：
1、将某一列的元素全部取反。
2、将某一行的元素全部取反。
你可以执行任意次操作。
Task：通过以上两种操作如果可以将整个矩阵的元素全变为正数的话，则输出最少的操
作次数，否则输出“impossible”（不包括双引号）。
Input
输入文件的第一行有两个整数n 和m(1≤n,m≤1000)，表示矩阵的大小。
接下来有N 行，每行M 个数，每个数之间有一个空格。
Output
通过以上两种操作如果可以将整个矩阵的元素全变为正数的话，则输出最少的操作次
数，否则输出“impossible”（不包括双引号）。
Sample Input
2 4
3 7 -6 1
-2 -6 8 -4
Sample Output
2
Hint
数据约定：
对于40%的数据,1≤N,M≤10
对于100%的数据，2≤N，M≤1000
思路：贪心+dfs
首先，我们可以预处理出每一行的负数个数和每一个位置的正负
那么我们在每次dfs里，求出最多负数的行或列（一个）
将这行或列取反，算出取反后的负数个数（如果说是行，会影响到当前列上的值；如果是列，会影响到当前行上的值）和每一个位置的正负
如果每次都判断一遍整个矩阵有没有负数，绝逼会TLE，那么就可以预处理出一个矩阵的负数个数，每次取反便改变
如果在800步内没有做出，输出impossible
代码：
var f:array[0..1001,0..1001]of boolean;
ans,n,m,all,i,j,x:longint;
h,l:array[0..1001]of longint;
procedure dfs(temp:longint);
var i,max,maxn,maxm:longint;
begin
if (all=0) then
begin
if (temp<ans) then ans:=temp;
exit;
end;
if (temp>800) then
begin
write('impossible');
halt;
end;
max:=0;maxn:=0;maxm:=0;
for i:=1 to n do if (max<h[i])then begin max:=h[i]; maxn:=i; maxm:=1; end;
for i:=1 to m do if (max<l[i])then begin max:=l[i]; maxn:=i; maxm:=2; end;
if (maxm=1) then
begin
h[maxn]:=m-h[maxn];
for i:=1 to m do
if (f[maxn][i]) then
begin
f[maxn][i]:=false;
inc(l[i]);
inc(all);
end
else
begin
f[maxn][i]:=true;
dec(l[i]);
dec(all);
end;
dfs(temp+1);
h[maxn]:=m-h[maxn];
for i:=1 to m do
if (f[maxn][i]) then
begin
f[maxn][i]:=false;
inc(l[i]);
inc(all);
end
else
begin
f[maxn][i]:=true;
dec(l[i]);
dec(all);
end;
end
else
begin
l[maxn]:=n-l[maxn];
for i:=1 to n do
if (f[i][maxn]) then
begin
f[i][maxn]:=false;
inc(h[i]);
inc(all);
end
else
begin
f[i][maxn]:=true;
dec(h[i]);
dec(all);
end;
dfs(temp+1);
l[maxn]:=n-l[maxn];
for i:=1 to n do
if (f[i][maxn])then
begin
f[i][maxn]:=false;
inc(h[i]);
inc(all);
end
else
begin
f[i][maxn]:=true;
dec(h[i]);
dec(all);
end;
end;
end;
begin
ans:=100000000;
readln(n,m);
for i:=1 to n do
begin
for j:=1 to m do
begin
read(x);
if x<0 then
begin
f[i][j]:=false;
inc(h[i]); inc(l[j]);
inc(all);
end
else f[i][j]:=true;
end;
end;
dfs(0);
writeln(ans);
end.
NO.3
Description
现在给你M 根柱子，初始的时候有N 个大小不一样的盘插在第一根柱子上面。同
样地，规格大的盘子不能放在规格比它小的盘子上面。问最少需要多少次的移动才能将
这N 个盘从第一根柱子移动到最后一根柱子上面？
Input
输入文件的第一行有两个整数n,m(1≤n≤100000,3≤m≤10)，分别表示有n 个盘子和m
根柱子。
Output
输出文件只有一行，一个整数，表示最少的移动次数。保证这个移动次数不会超过
2^63-1。
Sample Input
4 3
Sample Output
15
数据约定：
对于30%的数据,M=3
对于80%的数据，1≤N≤100,3≤M≤10
对于100%的数据，1≤N≤100000,6≤M≤10
思路：DP
设f[i][j]为i个盘子j根柱子的最小移动步数
状态转移方程为2*f[k][j]+f[i-k][j-1]
（其实这个方程有点像分治）意思就是，将一个几个盘子分成两份，如下图
那么这个决策点k怎么去枚举呢，假设g[i]表示有i个盘子时的决策点，g[i]=g[i-1]
如果当前决策点不够它的+1优，就+1
代码：
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
unsigned long long f[100010][12];
int g[100010];
int main()
{
int n,m;
scanf("%d%d",&n,&m);
for (int j=3;j<=m;j++)
{
g[0]=0;
for (int i=1;i<=n;i++)
{
if (j==3) {f[i][j]=f[i-1][j]*2+1; continue;}
g[i]=g[i-1];
if (i<j) f[i][j]=i*2-1; else
{
int k=g[i];
f[i][j]=2*f[k][j]+f[i-k][j-1];
if (f[k+1][j]*2+f[i-k-1][j-1]<f[i][j]) f[i][j]=f[k+1][j]*2+f[i-k-1][j-1],g[i]++;
}
}
}
printf("%lld",f[n][m]);
}NO.4
Description
Z 国是一个拥有N 个岛的国家。这N 个岛用N-1 条桥来连接，且任意两个岛之间都可以互达。
某商人听说Z 国是一个很富有的国家，所以他想到Z 国闯一闯。经过他仔细的观察，他发现某样商品特别受欢迎，而且由于各岛之间沟通联系不够多，所以这样物品在每个岛的价格可能都不同。
Task：商人开始在编号为x 的岛上，然后他要走到编号为y 的岛上。在这期间，他可以在x 岛y 的路径上买一件商品，和卖一件商品。，注意，仅能买一件和卖一件！显然你要计算商人从岛x 到岛y 最多能赚多少钱。
Input
输入第一行有一个整数N(1≤n≤50000)，表示Z 国有N 个岛。
接下来有N 行，每行一个整数Ci(1≤Ci≤50000)，第N+i 行的Ci 表示商品在岛i 的价
格。
再接下来有N-1 行，每行两个整数x,y(1≤x,y≤50000)，表示岛x 和岛y 之间有一条
桥。
接下来有一个整数M，表示有M 个询问。
然后M 行，每行两个整数，x,y(1≤x,y≤50000)，表示询问你，商人从岛x 到岛y 最多
能赚多少钱？
Output
对于每次询问，如果商人能赚到钱，则输出最多能赚多少钱。
如果不能赚钱，就输出0（你可以这样理解——亏本生意谁都不会做^_^）
Sample Input
4
1
2
3
4
1 2
1 4
2 3
3
1 3
3 1
1 4
Sample Output
2
0
3
Hint
数据约定：
对于30%的数据, 1≤N,M≤100
对于60%的数据，1≤N,M≤1000
对于100%的数据，1≤N,M≤50000
思路：Tarjan
代码:
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int n,m,i,next[1000001],last[100001],bridge[100001],tot,a[50001],x[50001],y[50001],ans,k[50001][101][3],b[50001],way[50001];
bool bz[50001];
int find(int t)
{
if (b[t]==t) return t;
else return find(b[t]);
}
void Tarjan(int l)
{
int i=last[l],yy=0;
bz[l]=true;
while (i)
{
yy=bridge[i];
if (bz[yy]==false)
{
Tarjan(yy);
b[yy]=l;
}
i=next[i];
}
for (i=1;i<=k[l][0][0];i++) if (bz[k[l][i][1]]) k[l][i][2]=find(k[l][i][1]);
}
void get(int l,int w)
{
if (l==w)
{
way[++way[0]]=l;
return;
}
else
{
way[++way[0]]=l;
get(b[l],w);
return;
}
}
void get2(int l,int w)
{
while (l==w)
{
get(b[l],w);
way[++way[0]]=l;
return;
}
}
int main()
{
int x1,y1;
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
b[i]=i;
}
for (int i=1;i<=n-1;i++)
{
scanf("%d%d",&x1,&y1);
tot++; bridge[tot]=y1; next[tot]=last[x1]; last[x1]=tot;
tot++; bridge[tot]=x1; next[tot]=last[y1]; last[y1]=tot;
}
scanf("%d",&m);
for (int i=1;i<=m;i++)
{
scanf("%d%d",&x[i],&y[i]);
k[x[i]][++k[x[i]][0][0]][1]=y[i];
k[y[i]][++k[y[i]][0][0]][1]=x[i];
}
Tarjan(1);
int w=0;
for (int i=1;i<=m;i++)
{
for (int j=1;j<=k[x[i]][0][0];j++)
if (k[x[i]][j][1]==y[i])
{
w=k[x[i]][j][2];
break;
}
if (w==0)
{
for (int j=1;j<=k[y[i]][0][0];j++)
if (k[y[i]][j][1]==x[i])
{
w=k[y[i]][j][2];
break;
}
}
way[0]=0;
get(x[i],w);get2(y[i],w);
int mx[50001],mn[50001],ans=0;
mn[0]=2147483647;mx[way[0]+1]=0;
for (int j=1;j<=way[0];j++) mn[j]=min(mn[j-1],a[way[j]]);
for (int j=way[0];j>=1;j--) mx[j]=max(mx[j+1],a[way[j]]);
for (int j=2;j<=way[0];j++) ans=max(ans,mx[j]-mn[j-1]);
printf("%d\n",ans);
}
}
扫一扫
453
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
