CF EDU138 D(数论) ，牛练104C(DP) ，焦作F. Honeycomb(复杂建图，BFS最短路)

一个感觉还不错的题
D. Counting Arrays
题意：当我们有一个数组，我们可以移除其和满足gcd(a[i],i)=1的元素(移除后自动补位)。现在我们有一个数组b，b的每个元素规定了当前我们要移除a中的那个元素，如果不能按照b的顺序来移除a的话那么b就不是一个合法的移除顺序数组。

显然的b的每个元素的取值范围必定为1到k-i+1。

当a有至少两个不同的合法的b数组时，我们称a为good数组。

现在给定n和m，要求你求出：长度为从1到n的所有可能的数组中good数组有多少个，数组中每个值都可以取1到m，结果对998244353取模

分析：
我们先手推了几组样例，

发现good数组的数目是很大的，而不满足good条件的数组有这样的特点：他们除了b数组取全1值之外没有其他的合法b数组了。

那么我们想是什么造成了这个原因，显然对于某个a[i]他有所有的下标j都满足gcd(a[i],j)!=1
也就是说，a[i]不会和任何的下标互质。

进一步思考发现a[i]如果不想和任何数互质，他需要满足的条件就是：和当前长度下出现的所有质数下标都不互质，那么要怎么达到呢？显然可以成为这些质数下标的lcm，而质数的lcm也很质朴就是两数乘积。

到了这里，基本就差不多了，假设乘积为r，那么m范围内为r的倍数的数就是m/r，所以就要从答案总数中减去：(之前长度范围下的满足条件的个数）*m/r

#include <bits/stdc++.h>

using namespace std;
#define int long long
const int mod = 998244353;
const int N = 3e5+100;
int fastpow(int n,int a)
{
    int res=1;
    a%=mod;
    while(n)
    {
        if(n&1)
            res=res*a%mod;
        n>>=1;
        a=a*a%mod;
    }
    return res%mod;
}
bool isPrime[N];
//isPrime[i] == 1表示：i是素数
vector<int> Prime;
//Prime存质数
void GetPrime(int n)//筛到n
{
	memset(isPrime, 1, sizeof(isPrime));
	//以“每个数都是素数”为初始状态，逐个删去
	isPrime[1] = 0;//1不是素数
	for(int i = 2; i <= n; i++)
	{
		if(isPrime[i])//没筛掉
			Prime.push_back(i); //i成为下一个素数

		for(int j=0;j<Prime.size()&&i*Prime[j]<= n/*不超上限*/; j++)
		{
			isPrime[i*Prime[j]] = 0;
			if(i % Prime[j] == 0)//i中也含有Prime[j]这个因子
				break; //重要步骤。见原理
		}
	}
}
signed main()
{
    int n,m;
    cin>>n>>m;
    GetPrime(n);
    int ans=0;
    for(int i=1;i<=n;i++)
        ans=(ans+fastpow(i,m))%mod;
    //cout<<ans<<endl;
    int cnt=1,num=1;
    for(int i=1;i<=n;i++)
    {
        if(isPrime[i])
            num*=i;
        if(num>m)
            break;
        cnt=cnt*(m/num%mod)%mod;
        ans=(ans-cnt+mod)%mod;
    }
    cout<<ans<<endl;
    return 0;
}

1919810

题意自己看吧，中文题面

思路：我们设DP状态为dp[i][j]是数字i作为第j位的答案数

那么根据题目要求，我们在统计第i个数字的时候要看其分别和0-9的关系来判断他适合做哪一个位置。

#include <bits/stdc++.h>
//https://codeforces.com/contest/1666/problem/J
using namespace std;
#define int long long
const int mod = 1e9+7;
const int N = 1e6+7;
char s[N];
int dp[15][15];
int a[N];
signed main()
{
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    cin>>(s+1);
    int n=strlen(s+1);
    for(int i=1;i<=n;i++)
    {
        a[i]=s[i]-'0';
    }
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        dp[a[i]][1]++;//任何数都有做为第一个数的权力
        for(int j=1;j<=7;j++)
        {
            if(j>i)
                continue;
            for(int k=0;k<=9;k++)
            {
                if(j==2||j==4)
                {
                    if(a[i]>k)
                    dp[a[i]][j]=(dp[a[i]][j]+dp[k][j-1])%mod;
                    /*else if(a[i]==k)
                    dp[a[i]][j]=dp[k][j]; 合理性转移，但是没必要*/
                }
                else
                {
                    if(a[i]<k)
                    dp[a[i]][j]=(dp[a[i]][j]+dp[k][j-1])%mod;
                }
            }

        }
    }
    for(int i=0;i<=9;i++)
    {
        ans=(ans+dp[i][7])%mod;
    }
    cout<<ans<<endl;
    return 0;
}

F. Honeycomb

题意：给定一个复杂度蜂窝状图形，然后蜂窝之间有东西挡着就说明不连通，没东西挡着说明连通，现在在图中规定一个点为S一个点为T，求从S蜂窝到T蜂窝的最短距离（最短距离时一共经过的节点数，这之中包含S和T两个点）。

思路：根据给出的图形建立连通图，然后BFS跑最短路，，建图过程非常非常复杂。

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+10;
const int M=2e6+10,inf=0x3f3f3f3f;
char s[N*4+10][N*6+10];
int vis[N*6+10][N*6+10];
int dir[6][2]={-1,3,1,3,1,-3,-1,-3,-2,0,2,0};
int val[6][2]={-2,6,2,6,2,-6,-2,-6,-4,0,4,0};
void getl(int x){
	char ch=getchar();
	int cnt=0;
	while(ch!='\n') s[x][++cnt]=ch,ch=getchar();
}
int n,m;
int getid(int x,int y)
{
    return vis[x][y];
}
vector<int>G[M];
int si=0,sj=0;
int ti=0,tj=0;
int dis[M];
int vs[M],vs1[M];
void bfs(int s)
{
    queue<int>que;
    que.push(s);
    dis[s]=1;
    while(que.size())
    {
        int u=que.front();que.pop();
 
        if(vs1[u]) continue;
        vs1[u]=1;
        for(int v:G[u])
        {
            if(dis[v]>dis[u]+1)
            {
                dis[v]=dis[u]+1;
                que.push(v);
            }
        }
    }
    if(dis[getid(ti,tj)]==inf) printf("-1\n");
    else
    printf("%d\n",dis[getid(ti,tj)]);
}
 
struct node
{
    int x,y;
};
int cnt;
 
void build(int x2,int y2)
{
    queue<node>que;
    que.push({x2,y2});
    vis[x2][y2]=++cnt;
    while(que.size())
    {
        node now=que.front();que.pop();
        if(vs[getid(now.x,now.y)]) continue;
        vs[getid(now.x,now.y)]=1;
        for(int i=0;i<6;++i)
        {
            int x=now.x+val[i][0];
            int y=now.y+val[i][1];
            if(x<1||x>n||y<1||y>m) continue;
            if(vis[x][y]==0)
            vis[x][y]=++cnt;
            int x1=now.x+dir[i][0];
            int y1=now.y+dir[i][1];
            que.push({x,y});
            if(x1<1||x1>n||y1<1||y1>m) continue;
            if(s[x1][y1]!='\\'&&s[x1][y1]!='/'&&s[x1][y1]!='-')
            {
                G[getid(now.x,now.y)].push_back(getid(x,y));
            }
        }
    }
}
 
int main()
{
	int _;cin>>_;while(_--)
	{
        scanf("%d%d", &n, &m);
        for(int i=1;i<=(n+1)*m;++i) {
            G[i].clear();
            vs[i]=vs1[i]=0;
            dis[i]=inf;
        }
        n = 4*n+3;
        m = 6*m+3;
        for(int i=1;i<=n;++i) for(int j=1;j<=m;++j) vis[i][j]=0;
        getchar();
        for(int i = 1; i <= n; ++i) getl(i);
        cnt=0;
        build(3,5);//建图编号和连边
        for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
        {
            if(s[i][j]=='S') si=i,sj=j;
            if(s[i][j]=='T') ti=i,tj=j;
        }
        int id=getid(si,sj);
        bfs(id);
    }
}