江理oj 摸底测试 解题报告

         http://oj.jxust.edu.cn/contest?id=1702

A  :::

思路：：开一个数组暂时记录一下每个杯子加的水量（假设无穷大）；再遍历一便数组如果大于当前杯子的容量，则将多余的水量移至下一水杯

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=1e5+5;

ll a[maxn],b[maxn];
int n,m;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        //memset(b,0,sizeof(b));
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++){
            scanf("%lld",&a[i]);
            b[i]=0;
        }
        while(m--){
            int x;
            ll y;
            scanf("%d%lld",&x,&y);
            b[x]+=y;
        }
        ll jw=0;
        for(int i=1;i<=n;i++){
            if(b[i]+jw>a[i]){
                jw=b[i]+jw-a[i];
                b[i]=a[i];
            }
            else if(b[i]+jw<a[i]){
                b[i]=b[i]+jw;jw=0;
            }
            else if(b[i]+jw==a[i]){
                b[i]=a[i];jw=0;
            }
        }
        for(int i=1;i<=n;i++){
            if(i==1){printf("%lld",b[i]);}
            else{printf(" %lld",b[i]);
            }
        }
        printf("
");
    }
    return 0;
}

B :::

思路：： 预处理：线性筛素数       枚举两个素数，再判断第三个数是否为素数（三个素数的关系   第一个素数 <= 第二个素数  <= 第三个素数 ）避免重复计数

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=4e4+5;
const int Maxn=1e8;

bool isprime[maxn];
int prime[maxn];
int num_prime=0;
void get_prime()
{
    isprime[0]=1;
    isprime[1]=1;
    for(int i=2;i<=maxn;i++){
        if(!isprime[i]){
            prime[num_prime++]=i;
        }
        for(int j=0;j<num_prime&&i*prime[j]<=maxn;j++){
            isprime[i*prime[j]]=1;
            if(i%prime[j]==0){break;}
        }
    }
}
int main()
{
    get_prime();
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        if(n<=5){
            printf("0
");continue;
        }
        int sum=0;
        for(int i=0;prime[i]<=n;i++){
            for(int j=i;prime[j]+prime[i]<=n;j++){
                if(isprime[n-prime[i]-prime[j]]==0&&(n-prime[i]-prime[j])>=prime[j]){sum++;}
            }
        }
        cout<<sum<<endl;
    }
    return 0;
}

C :::

思路：：分别对 x y z 排序，再对全部建立的边排序，再跑一下克鲁斯卡尔即可；

由题意可以知当你在某两点之间建立边时，你只会用 X，Y，Z 中的一种建立，而对X排序的话保证了相邻的两点建边花费最小（必然不会选择与其他点建立）所以只需建立n-1条边，对Y，Z同样的道理，跑克鲁斯卡尔

//#include<bits/stdc++.h>
#include<iostream>
#include<stdio.h>
#include<string>
#include<string.h>
#include<algorithm>
#include<stack>
#include<set>
#include<map>
#define ll long long
using namespace std;
const int maxn=2e5+5;
const int inf=1e9+7;

struct node
{
    int x,y,z,pos,val;
}a[maxn],b[maxn*3];
int f[maxn];
bool cmp1(node A,node B)
{
    return A.x<B.x;
}
bool cmp2(node A,node B)
{
    return A.y<B.y;
}
bool cmp3(node A,node B)
{
    return A.z<B.z;
}
bool cmp4(node A,node B)
{
    return A.val<B.val;
}
int getfind(int x)
{
    return f[x]==x?x:f[x]=getfind(f[x]);
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);
        a[i].pos=i;
        f[i]=i;
    }
    int ant=0;
    sort(a+1,a+n+1,cmp1);
    for(int i=1;i<n;i++){
        b[++ant].x=a[i].pos;
        b[ant].y=a[i+1].pos;
        b[ant].val=abs(a[i].x-a[i+1].x);
    }
    sort(a+1,a+n+1,cmp2);
    for(int i=1;i<n;i++){
        b[++ant].x=a[i].pos;
        b[ant].y=a[i+1].pos;
        b[ant].val=abs(a[i].y-a[i+1].y);
    }
    sort(a+1,a+n+1,cmp3);
    for(int i=1;i<n;i++){
        b[++ant].x=a[i].pos;
        b[ant].y=a[i+1].pos;
        b[ant].val=abs(a[i].z-a[i+1].z);
    }
    sort(b+1,b+ant+1,cmp4);
    int cnt=1,sum=0;
    for(int i=1;i<=ant;i++){
        int t1=getfind(b[i].x);
        int t2=getfind(b[i].y);
        if(t1!=t2){
            f[t2]=t1;
            cnt++;
            sum+=b[i].val;
        }
        if(cnt>=n){break;}
    }
    cout<<sum<<endl;
    return 0;
}

D :::

思路：：

E :::

思路：：预处理前dp[i](1<=i<=5)   转态转移方程 dp[i]=max(dp[j]*dp[i-j])(j=1,2~i/2);再就是求逆元，

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=4e4+5;
const int Maxn=1e8;

ll a[105];
ll exgcd(ll a,ll b,ll &x,ll &y)
{
    if(b==0){
        x=1;
        y=0;
        return a;
    }
    int r=exgcd(b,a%b,x,y);
    int t=x;
    x=y;
    y=t-a/b*y;
    return t;
}
int main()
{
    ll n;
    scanf("%lld",&n);
    a[1]=1,a[2]=2,a[3]=3,a[4]=4;
    for(ll i=5;i<=n;i++){
        ll ans=0;
        for(ll j=1;j<=i/2;j++){
            ans=max(ans,a[j]*a[i-j]);
        }
        a[i]=ans;
    }
    ll x,y;
    exgcd(n,a[n],x,y);
    printf("%lld
",(x+a[n])%a[n]);
    return 0;
}

F :::

思路：：线段树区间更新，只需对lazy标记处理，只有 lazy值为奇数时反转，

//#include <bits/stdc++.h>
#include<string.h>
#include<stdio.h>
#include<iostream>
#include<string>
#include<algorithm>
#define ll long long
using namespace std;

const int maxn=1e5+5;
int lazy[maxn<<2];

void build(int l,int r,int rt)
{
    lazy[rt]=0;
    if(l==r){
        return ;
    }
    int mid=(l+r)>>1;
    build(l,mid,2*rt);
    build(mid+1,r,2*rt+1);
}
void pushup(int rt)
{
    if(lazy[rt]!=0){
        if(lazy[rt]%2==0){lazy[rt]=0;return ;}
        lazy[2*rt]+=lazy[rt];
        lazy[2*rt+1]+=lazy[rt];
        lazy[rt]=0;
    }
}
void update(int L,int R,int l,int r,int rt)
{
    if(L<=l&&R>=r){
        lazy[rt]++;
        return ;
    }
    pushup(rt);
    int mid=(l+r)>>1;
    if(L<=mid){
        update(L,R,l,mid,2*rt);
    }
    if(mid<R){
        update(L,R,mid+1,r,2*rt+1);
    }
}
int query(int tr,int l,int r,int rt)
{
    if(l==r){
        if(lazy[rt]&1){
            return 1;
        }
        else{
            return 0;
        }
    }
    pushup(rt);
    int mid=(l+r)>>1;
    if(tr<=mid){
        query(tr,l,mid,2*rt);
    }
    else{
        query(tr,mid+1,r,2*rt+1);
    }
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    build(1,n,1);
    while(m--)
    {
      int op,a,b;
      scanf("%d",&op);
      if(op==1){
        scanf("%d%d",&a,&b);
        update(a,b,1,n,1);
      }
      else{
        scanf("%d",&a);
        printf("%d
",query(a,1,n,1));
      }
    }
    return 0;
}

G :::

思路：： 最少派2个人去，最多派n个人去，对于每个去的人来讲有两种选择（送或接礼物）但要除去全接和全收礼物的情况

阶乘逆元模板

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=1e5+5;
const ll MOD=1e9+7;

ll fa[maxn],inv[maxn];
ll qpow(ll x,ll p)
{
    ll ans=1;
    while(p){
        if(p&1){
            ans=(ans*x)%MOD;
        }
        x=(x*x)%MOD;
        p>>=1;
    }
    return ans;
}
void pre()
{
    fa[0]=1;
    for(int i=1;i<=maxn;i++){
        fa[i]=(fa[i-1]*i)%MOD;
    }
    inv[maxn]=qpow(fa[maxn],MOD-2);
    for(int i=maxn-1;i>=0;i--){
        inv[i]=inv[i+1]*(i+1)%MOD;
    }
}
int main()
{
    pre();
    int n;
    scanf("%d",&n);
    if(n==1){
        printf("0
");return 0;
    }
    ll sum=0;
    for(int i=2;i<=n;i++){
        sum=(sum+fa[n]*inv[i]%MOD*inv[n-i]%MOD*(qpow(2,i)-2)%MOD)%MOD;
    }
    printf("%lld
",sum);
    return 0;
}

 H :::

思路：：跑三遍最短路，第一，第二遍判断他们之间是否存在相同的能到达终点的最短路，存在则再将两地图为合并（两者都为 " * " 时才为 ” * ” ，反之 “ # ” ），第三遍跑合并地图判断最短路是否为之前的最短路相等

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=505;
const int inf=1e9+7;

char mp1[maxn][maxn],mp2[maxn][maxn];
int n,m;
struct node
{
    int x,y,step;
    node(){}
    node(int _x,int _y,int _step):x(_x),y(_y),step(_step){}

};
int fx[]={0,0,1,-1};
int fy[]={1,-1,0,0};
bool vis[maxn][maxn];
int s1=1e9,s2=1e9;

void bfs1()
{
    memset(vis,0,sizeof(vis));
    queue<node>q;
    node t,p;
    q.push(node(1,1,0));
    vis[1][1]=1;
    while(!q.empty())
    {
        t=q.front();
        q.pop();
        if(t.x==n&&t.y==m){
            s1=t.step;return ;
        }
        for(int i=0;i<4;i++){
            p.x=t.x+fx[i];
            p.y=t.y+fy[i];
            if(p.x>=1&&p.x<=n&&p.y>=1&&p.y<=m&&mp1[p.x][p.y]!='#'&&vis[p.x][p.y]==0){
                p.step=t.step+1;
                vis[p.x][p.y]=1;
                if(p.x==n&&p.y==m){
                    s1=p.step;return ;
                }
                q.push(node(p.x,p.y,p.step));
            }
        }
    }
}
void bfs2()
{
    memset(vis,0,sizeof(vis));
    queue<node>q;
    node t,p;
    q.push(node(1,1,0));
    vis[1][1]=1;
    while(!q.empty())
    {
        t=q.front();
        q.pop();
        if(t.x==n&&t.y==m){
            s2=t.step;return ;
        }
        for(int i=0;i<4;i++){
            p.x=t.x+fx[i];
            p.y=t.y+fy[i];
            if(p.x>=1&&p.x<=n&&p.y>=1&&p.y<=m&&mp2[p.x][p.y]!='#'&&vis[p.x][p.y]==0){
                p.step=t.step+1;
                vis[p.x][p.y]=1;
                if(p.x==n&&p.y==m){
                    s2=p.step;return ;
                }
                q.push(node(p.x,p.y,p.step));
            }
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    getchar();
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%c",&mp1[i][j]);
        }
        getchar();
    }
    //getchar();
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%c",&mp2[i][j]);
        }
        getchar();
    }
    bfs1();
    bfs2();
    if(s1==1e9||s2==1e9||s1!=s2){
        cout<<"NO"<<endl;return 0;
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(mp1[i][j]=='*'&&mp2[i][j]=='*'){
                mp1[i][j]='*';
            }
            else{
                mp1[i][j]='#';
            }
        }
    }
    s1=1e9;
    bfs1();
    if(s1==s2){
        cout<<"YES"<<endl;
    }
    else{
        cout<<"NO"<<endl;
    }
    return 0;
}

I :::

思路：：若a[i]与a[n-i-1]不等则令大的赋值成小的

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=1e5+5;
const int inf=1e9+7;
int gcd(int x,int y)
{
    return y==0?x:gcd(y,x%y);
}
char a[maxn];
int main()
{
    int n;
    scanf("%s",a);
    n=strlen(a);
    for(int i=0;i<n/2;i++){
        if(a[i]==a[n-i-1]){continue;}
        if(a[i]>a[n-i-1]){
            a[i]=a[n-i-1];
        }
        else{
            a[n-i-1]=a[i];
        }
    }
    printf("%s
",a);
    return 0;
}