Codeforces #174 Div2

A Cows and Primitive Roots

　　原根，目前只有暴力求解，看了百度百科才知道。因为 x < p,  且 p <= 2000

#include<stdio.h>
#include<stdlib.h>


int p;

int pow( int x, int n ){
    int res = 1;
    while( n ){
        if( n&1 ) res = (res*x)%p;
        x = x*x%p;
        n >>= 1; 
    }
    return res;
}

bool legal( int x ){
    if( pow( x, p-1 ) - 1 ) return false;
    else{
        for(int i = 1; i < p-1; i++ )
            if( (pow(x,i)-1) == 0 ) return false;
        return true;
    }
}
int main(){
    while( scanf("%d", &p) != EOF)
    {
        int res = 0;
        for(int x = 1; x < p; x++ )
        {
            if( legal( x ) )
                res++;
        }
        printf("%d\n", res );    
    }
    return 0;
}

 

B Cows and Poker Game

　　题目描述的，最后一句话感觉有点坑，若其他人为 F或 A， 自己是A或I 才可以举手，只需要统计I数量，

然后分析即可。

#include<stdio.h>
#include<string.h>


const int N = 200007;
char str[N];

int main(){
    int n;
    while( scanf("%d", &n) != EOF )
    {
        scanf("%s", str );
        int len = strlen(str);
        int cnt_A = 0, cnt_I = 0;    
        for(int i = 0; i < len; i++)
            if( str[i] == 'I' ) cnt_I++;
            else if( str[i] == 'A' ) cnt_A++;    
        if( cnt_I == 1 ) printf("1\n");
        else if( cnt_I == 0 ) printf("%d\n", cnt_A);
        else    printf("0\n");
    }
    return 0;
}

 

C Cows and Sequence

　　区间更新，单点更新，区间求和，可以用线段树来维护，时间复杂度为 Nlog(N) ，

不过要注意原本里头有1个元素了，极限再添加 N个， 则最大有 N+1 个节点

　　解法2，主要还是区间更新然后删除最后一个节点时候的处理，其实可以借鉴线段树区间更新，

中的 push_down 操作，借助辅助数组来实现，代码可以很精简。

解法一代码

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;

#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
typedef long long LL;

const int N = 200010;

LL sum[N<<2], add[N<<2];
void push_up( int rt ){
    sum[rt] = sum[rt<<1] + sum[rt<<1|1];
}
void push_down( int rt, int m){
    if( add[rt] ){
        add[rt<<1] += add[rt];
        add[rt<<1|1] += add[rt];    
        sum[rt<<1] += (LL)(m-(m>>1))*add[rt];
        sum[rt<<1|1] += (LL)(m>>1)*add[rt];
        add[rt] = 0;
    }
}

void build( int l, int r, int rt ){
    add[rt] = sum[rt] = 0;
    if( l == r ) return;
    int m = (l+r)>>1;
    build( lson );
    build( rson );
    //push_up( rt );
}
void update( int L, int R, LL c, int l, int r,int rt ){
    if( (L<=l) && (r<=R) ){
        add[rt] += c;
        sum[rt] += (LL)c*(r-l+1);
        return;    
    }
    push_down( rt, r-l+1 );
    int m = (l+r)>>1;
    if( L <= m ) update( L, R, c, lson );
    if( m < R ) update( L, R, c, rson );
    push_up( rt );
}
LL query( int L, int R, int l, int r, int rt ){
    if( (L<=l) && (r<=R) )
        return sum[rt];
    push_down( rt, r-l+1 );
    int m = (l+r)>>1;
    LL ret = 0;
    if( L <= m ) ret += query( L, R, lson );
    if( m < R )  ret += query( L, R, rson );
    return ret;
}

int main(){
//    freopen("1.in", "r", stdin);
//    freopen("test.out","w",stdout);

    int T, n = 1, maxn = 200001;
    build( 1, maxn, 1 );    

    scanf("%d", &T);
    for(int i = 0; i < T; i++){
        int op, a, b;
        scanf("%d", &op);
        if( op == 1 ){
            scanf("%d%d", &a, &b );
            update( 1,a, b,  1,maxn,1 ); 
        }
        else if( op == 2 ){
            scanf("%d", &a );
            n++;
            update( n,n,a, 1,maxn, 1 );        
        }
        else{
            if( n > 1 ) {
                LL tmp = query( n,n, 1,maxn,1 );    
                update( n,n, -tmp, 1,maxn, 1 );
                --n;    
            }    
        }
    
        LL res = query( 1, maxn, 1, maxn, 1 );
//        printf("%lld\n", res );
                printf("%.9lf\n", res*1./n );
    }    
    return 0;
}

解法二代码

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef long long LL;

const int N = 2e5+10;
LL s, a[N], c[N];

int main(){
    int n = 1, m;
    scanf("%d", &m);
    while( m-- ){
        int op, x, y;
        scanf("%d", &op);
        if( op == 1 ){
            scanf("%d%d", &x,&y);    
            s += (1LL)*x*y; c[x] += y;
        }
        else if( op == 2 ){
            scanf("%d", &y);
            s += y; a[++n] = y;
        }
        else{
            s -= a[n]; a[n] = 0;
            c[n-1] += c[n]; 
            s -= c[n]; c[n] = 0;
            --n;
        }    
        printf("%.9lf\n", s*1./n);    
    }
    return 0;
}

 

D Cow Program

　　因为 A【1】 每次都在变换，但是操作对于x而言只有 +a[x] ,与 -a[x]，

若其第二次回到 1 位置，若为 +a[x]， 则陷入死循环，若为 -a[x]，则必定 1-a[1] 终断，

所以我们可以得出结论，a[1] = i ，的值虽然变换，但不对后面的产生影响，所以可以使用

记忆化搜索或者DP来解。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
using namespace std;

typedef long long LL;

const int N = 2e5+10;

LL dp[2][N];
int n, a[N];
int vis[2][N];

LL dfs( int i, int cur, int x ){
    if( x <= 0 || x > n ) return 0;
    // 循环，继续走下去回陷入循环 
    if( (vis[cur][x] == i) || (vis[cur][x] == -1 ) ) return -1;

    if( vis[cur][x] ) return dp[cur][x];
    vis[cur][x] = i;    
    
    LL tmp = dfs( i, !cur, x + (cur?(-a[x]):a[x]) );

    if( tmp == -1 ) return (vis[cur][x] = -1);
    else    return dp[cur][x]= tmp+a[x];

}
int main(){
    scanf("%d", &n );
    for(int i = 2; i <= n; i++)
        scanf("%d", &a[i] );
    for(int i = 1; i <= n-1; i++)
    {
        vis[0][1]=0,a[1] = i;
        LL y = dfs(i, 0, 1);
        printf("%lld\n", y );    
    }
    return 0;
}

 

D Coin Troubles

　　还没有写，A了后再来补充～～～