Codeforces Round #258 (Div. 2)

A. Game With Sticks

题意 : 给你 n 条横线 ， m条竖线 ， 会有 n * m 个交点 ， 每人每次删掉一个点，并且连带删掉相关的横线和竖线 ，不能删就输 ， 问先手是否能胜。

思路 : 每次至少删掉一个横线和一个竖线，所以判断 min( n , m ) 的奇偶性就行了

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

int main(){
    int n , m ;
    while( scanf( "%d%d" , &n , &m ) != EOF ) {
        int cnt = min( n , m ) ;
        if( cnt % 2 == 0 ) {
            puts( "Malvika" ) ;
            continue ;
        }else{
            puts("Akshat" ) ;
            continue ;
        }
    }
    return 0 ;
}

B. Sort the Array

题意 ： 给你一个区间 ， 问你能不能翻转其中一个区间，得到一个递增序列 ， 如果已经递增输出 1 1 就好了

思路 ：细心点判判各种情况就好 ，不多说

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

int n ;
int a[100005] ;

int main(){
    while( scanf( "%d" , &n ) != EOF ){
        for( int i = 1 ; i <= n ; i ++ ) {
            scanf( "%d" , &a[i] ) ;
        }
        a[n+1] = 1000000009 ;
        bool find = false ;
        bool ok = true ;
        int s = 99999999 , t = -1 ;
        for( int i = 1 ; i < n ; i ++ ) {
            if( a[i] > a[i+1] ) {
                s = min( s , i ) ;
                if( find ) {
                    ok = false ;
                    break;
                }
            }else{
                if( s != 99999999 && !find ) {
                    t = i ;
                    find = true ;
                }
            }
        }
        if( ok == false ) {
            puts( "no" ) ;
            continue ;
        }
        if( s != 99999999 && t == -1 ) {
            t = n ;
        }
        if( s == 99999999 ) {
            puts(  "yes" ) ;
            printf( "1 1\n" ) ;
            continue ;
        }
        swap( a[s] , a[t] ) ;
        if( ( s == 1 || a[s-1] < a[s] ) && ( a[t] < a[t+1] ) ) {
            puts( "yes" )  ;
            printf( "%d %d\n" , s , t ) ;
        }else{
            puts("no" ) ;
        }
    }
    return 0 ;
}

C. Predict Outcome of the Game

题意: 三只队伍 ， n 场比赛 ， 你已经错过了k场 ， 但你知道这k场比赛的结果是 ，team1 和 team2 的胜场差是d1 ， team2 和 team3 的胜场差是d2 ，每场比赛不是胜就是败，问最后有没有可能平局。
思路 : 思路 : 首先假设第一只队伍的胜场为0 ， 那么枚举d1，d2 的正负 ， 有四种情况 ，得到team1，team2，team3 之后全都修正为非负数 。 那么首先3个队伍的胜场数和应该小于等于k ， 然后将三只队伍的胜场数补齐，看看总数是不是大于n了，然后还要看看n是不是能被3整数

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

typedef __int64 LL ;
LL n , k , d1 , d2 ;

int main(){
    int cas ;
    scanf( "%d" , &cas ) ;
    while( cas -- ) {
        scanf( "%I64d%I64d%I64d%I64d" , &n , &k , &d1 , &d2 ) ;
        LL win[3] ; LL left ;
        left = n - k ;
        win[0] = 0 ;
        win[1] = win[0] + d1 ;
        win[2] = win[1] + d2 ;
        sort( win , win + 3 ) ;
        if( win[0] < 0 ) {
            LL tmp = -win[0] ;
            win[0] += tmp ;
            win[1] += tmp ;
            win[2] += tmp ; 
        }
        left -= win[2] - win[0] ;
        left -= win[2] - win[1] ;
        if( ( ( k - win[0] - win[1] - win[2] ) % 3 == 0 )&& win[0] + win[1] + win[2]<= k && left >= 0 && left % 3 == 0 ) {
            puts( "yes" ) ;
            continue ;
        }
        left = n - k ;
        win[0] = 0 ;
        win[1] = win[0] - d1 ;
        win[2] = win[1] + d2 ;
        sort( win , win + 3 ) ;
        if( win[0] < 0 ) {
            LL tmp = -win[0] ;
            win[0] += tmp ;
            win[1] += tmp ;
            win[2] += tmp ; 
        }
        left -= win[2] - win[0] ;
        left -= win[2] - win[1] ;
        if( ( ( k - win[0] - win[1] - win[2] ) % 3 == 0 )&& win[0] + win[1] + win[2]<= k && left >= 0 && left % 3 == 0 ) {
            puts( "yes" ) ;
            continue ;
        }
        left = n - k ;
        win[0] = 0 ;
        win[1] = win[0] + d1 ;
        win[2] = win[1] - d2 ;
        sort( win , win + 3 ) ;
        if( win[0] < 0 ) {
            LL tmp = -win[0] ;
            win[0] += tmp ;
            win[1] += tmp ;
            win[2] += tmp ; 
        }
        left -= win[2] - win[0] ;
        left -= win[2] - win[1] ;
        if( ( ( k - win[0] - win[1] - win[2] ) % 3 == 0 )&& win[0] + win[1] + win[2]<= k && left >= 0 && left % 3 == 0 ) {
            puts( "yes" ) ;
            continue ;
        }
        left = n - k ;
        win[0] = 0 ;
        win[1] = win[0] - d1 ;
        win[2] = win[1] - d2 ;
        sort( win , win + 3 ) ;
        if( win[0] < 0 ) {
            LL tmp = -win[0] ;
            win[0] += tmp ;
            win[1] += tmp ;
            win[2] += tmp ; 
        }
        left -= win[2] - win[0] ;
        left -= win[2] - win[1] ;
        if( ( ( k - win[0] - win[1] - win[2] ) % 3 == 0 )&& win[0] + win[1] + win[2]<= k && left >= 0 && left % 3 == 0 ) {
            puts( "yes" ) ;
            continue ;
        }
        puts( "no" ) ;
    }
    return 0 ;
}

D. Count Good Substrings

题意 : 有一个字符串 只有 a 和 b ， 如果一个子串将连续的字符合并之后是回文串，那么这个字符串是good substring ， 问一个字符串当中有多少长度为奇数和长度为偶数的good Good Substrings 。
思路 : 首先要想到 ， 如果一个子串的首尾相同 ， 那么一定是good substring 。 然后用s[0/1]['a'/'b'] 表示当前出现在 奇/偶 位置的 'a'/'b' 有多少个 ， 然后扫一遍统计就行了

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

typedef __int64 LL ;

char str[100005] ;
int s[2][2] ;

int main(){
    while( scanf( "%s" , str ) != EOF ) {
        int len = strlen( str ) ;
        LL even = 0 , odd = 0 ;
        memset( s , 0 , sizeof(s) ) ;
        for( int i = 1 ; i <= len ; i ++ ) {
            s[i&1][str[i-1]-'a'] ++ ;
            even += s[(i&1)^1][str[i-1]-'a'] ;
            odd  += s[i&1][str[i-1]-'a'] ;
        }
        printf( "%I64d %I64d\n" , even , odd ) ;
    }
    return 0 ;
}