2013 蓝桥杯B组C++

剪格子 https://www.dotcpp.com/oj/problem1432.html

解题思路:dfs从左上角向四个方向搜索，用bool数组判断保证在一次搜索中不重复遇到同一顶点。

注意:输入是先列后行

实现代码：

#include<cstdio>
#include<algorithm>
using namespace std;

const int INF = 1e9;
const int Max_N = 10;

int n,m;
int number[Max_N][Max_N];
bool visited[Max_N][Max_N];
int sum;
int res = INF;

void dfs(int x, int y, int num, int cnt);

int main()
{
    scanf("%d%d",&m,&n);
    for( int i=0; i<n; i++ )
    {
        for( int j=0; j<m; j++ )
        {
            scanf("%d",&number[i][j]);
            sum += number[i][j]; 
        }
    }
    
    dfs(0,0,0,0);
    if( res==INF )    printf("0
");
    else            printf("%d
",res);
    
    return 0;
}

void dfs(int x, int y, int num, int cnt)
{
    if( x<0 || x>=n || y<0 || y>=m || num>sum/2 || cnt>=res || visited[x][y] )
        return;
    
    visited[x][y] = true;
    num += number[x][y];
    cnt++;
    
    if( num==sum/2 )
    {
        res = min( res, cnt );
    }
    
    dfs(x+1,y,num,cnt);
    dfs(x-1,y,num,cnt);
    dfs(x,y+1,num,cnt);
    dfs(x,y-1,num,cnt);
    
    visited[x][y] = false;
}

---

翻硬币  https://www.dotcpp.com/oj/problem1453.html

解题思路：开关问题

　　1.硬币区间翻转的顺序对结果无影响

　　2.同一个区间([i,i+1])重复翻是多余操作

　　所以我们规定从左到右判断，若不同则必须翻转，再此之后该位置就不需要考虑，问题规模-1。

实现代码：

#include<algorithm>
#include<iostream>
#include<string> 
using namespace std;

void clip(string &s, int i)
{
    if( s[i]=='*' )    s[i] = 'o';
    else            s[i] = '*';
}

int main()
{
    string s1,s2;
    cin>>s1>>s2;
    
    int res = 0;
    for( int i=0; i<s1.length()-1; i++ )
    {
        if( s1[i]!=s2[i] )
        {
            clip(s1,i);
            clip(s1,i+1);
            res++;
        }
    }
    cout<<res<<endl;
    
    return 0;
}

---

连号区间数  https://www.dotcpp.com/oj/problem1456.html

解题思路:解题的关键是连号区间数的判断--区间最大值与最小值之差是否等于区间长度。

实现代码：

#include<cstdio>
#include<algorithm>
using namespace std;

const int Max_N = 5000;

int N;
int p[Max_N];

int main()
{
    scanf("%d",&N);
    for( int i=0; i<N; i++ )    scanf("%d",&p[i]);
    
    int res = N; //区间长度为1 
    for( int i=0; i<N-1; i++ )
    {
        int min_p = p[i], max_p = p[i];  //区间[i,j]的两个极值 
        for( int j=i+1; j<N; j++ )
        {
            min_p = min( min_p, p[j] );
            max_p = max( max_p, p[j] );
            if( (max_p-min_p) == (j-i) )    res++; //满足条件 
        }
    }
    printf("%d
",res);
    
    return 0;
}

---

幸运数  https://www.dotcpp.com/oj/problem1441.html

解题思路:暴力求解，简化之处:用step记录从1开始没被删除数字的个数，若step%cur(当前幸运数)则删除当前遍历的数字。

实现代码

#include<cstdio>
#include<cstring>

const int Max_N = 1000000;

int m,n;
bool dp[Max_N+1]; //dp[i] = false表示i被删除 

int main()
{
    int m,n;
    scanf("%d%d",&m,&n);
    
    memset(dp,true,sizeof(dp));
    int cur = 2;
    while( cur<=n )
    {
        int step = 0;
        for( int i=1; i<=n; i++ )
        {
            if( dp[i]==true )
            {
                step++;
                if( step%cur==0 )
                {
                    dp[i] = false;
                }
            }
        }
        cur++;
        while( !dp[cur] ) cur++; 
    }
    
    int res = 0;
    for( int i=m+1; i<n; i++ )
    {
        if( dp[i] )    res++;
    }
    printf("%d
",res);
    
    return 0;
}

---

高僧斗法  https://www.dotcpp.com/oj/problem1459.html

解题思路：解题Nim博弈问题，Nim博弈问题：参考  https://www.cnblogs.com/jiangjun/archive/2012/11/01/2749937.html

　　Nim博弈问题说的是有几堆石子堆，两人轮流在任意石堆拿大于1个石子，最后拿光者得胜。博弈问题的结论是将所有石子堆数目异或，若为0则先手负，否则先手胜。

对于先手负的一方即使尽量想破坏局势，先手胜的一方只要每次都在取后保证局面仍然是胜局势即可.

　　应用于本题：

　　将小和尚两两配对，如{a1, a2, a3, a4 } 将(a1,a2)与(a3,a4)配对，其间隔看作可以取的石子，最后取完者胜。我的理解是对于必胜的策略其先后对结果无影响，那么可以先将处于高台阶的a3取到最上面，之后

取a1，a2，此时a2向上多少a1也可向上多少，a2与a3之间的间隔对结果无影响。(还不是特别清晰)

　　对每个石子堆的数目遍历,直到与其他石子堆异或的结果异或为0.

　　注意：每个石子堆数目既可以增加也可以减少！

实现代码：

#include<cstdio>

const int Max_N = 100;

int a[Max_N];
int num[Max_N];

int main()
{
    int index = 0; 
    while( scanf("%d",&a[index])!=EOF )
        index++;
    
    int xor_ = 0; 
    for( int i=0; i<index-1; i+=2 )
    {
        num[i/2] = a[i+1] - a[i] - 1; //石子堆 两两配对 
        xor_ ^= num[i/2]; //所有石子堆异或结果 
    }
    
    if( xor_==0 ) //必败 
    {
        printf("%d
",-1);
    }
    else
    {
        bool flag = false;
        for( int i=0; i<index-1; i++ )
        {
            int x = num[i/2]^xor_;//a^b^a = b x为除该堆外其他堆异或结果 
            for( int k=a[i]+1; k<a[i+1]; k++ )
            {
                /* 两个堆之间的num[i]可以增大/减小 */
                /* 若a增大 b-a减小  若b增大 b-a增大 */
                if( i%2==0 && ((a[i+1]-k-1)^x)==0 )
                {
                    printf("%d %d
",a[i], k );
                    flag = true;
                    break;
                }
                else if( i%2==1 && ((k-a[i-1]-1)^x)==0 )
                {
                    printf("%d %d
", a[i], k );
                    flag = true;
                    break;
                }
            }
        
            
            if( flag )    break;
        }
    }
    
    return 0;
}