zoj2686

Cycle Game

Time Limit: 5 Seconds
Memory Limit: 32768 KB

Here is a game played on a cycle by two players. The rule of this game is as follows: At first, a cycle is given and each edge is assigned a non-negative integer. Among those integers, at least one is zero. Further a coin is put on a vertex of the cycle.
From this vertex, the game starts and proceeds with two players' alternating moves with the following series of choices:

Choose an edge incident with the vertex having the coin,
Decrease the value of this edge to any non-negative integer strictly,
Move the coin to the adjacent vertex along this edge.

The game ends when a player on his turn cannot move because the value of each edge incident with the vertex having the coin is equal to zero. Then, that player is the loser.

Figure 1 illustrates an actual game. In this game, Alice is the first player and Bob is the second player. In the starting position in Figure 1 (a), Alice cannot but choose the right edge of the vertex having the coin. Alice then decreases its value from
2 to 0, and moves the coin along this edge, which makes (a) into (b). Next, Bob cannot but choose the down edge of the vertex having the coin; he then decreases its value from 5 to 1, which makes (b) into (c). In Figure 1 (c), Alice chooses the up edge of
the vertex having the coin and decreases its value from 1 to 0, which makes (c) into (d). Finally, in Figure 1 (d), Bob has no move since each edge incident with the vertex having the coin is assigned to zero. Then, Alice wins this game.



Figure 1: An example of cycle game (A coin is put on the black vertex)
In fact, whenever the game starts as shown in Figure 1 (a), the first player can always win for any second player's move. In other words, in the starting position in Figure 1 (a), the first player has a winning strategy. In this problem, you should determine
whether or not the first player has a winning strategy from a given starting position.

Input

The input consists of T test cases. The number of test cases (T) is given on the first line of the input file. Each test case starts with a line containing an integer N (3 <= N <= 20), where N is the number of vertices in a cycle. On the next line, there
are the N non-negative integers assigned to the edges of the cycle. The N integers are given in clockwise order starting from the vertex having the coin and they are separated by a single space. Note that at least one integer value among the N integers must
be zero and that the value of no integer can be larger than 30.

Output

Print exactly one line for each test case. The line is to contain "YES" if the first player has a winning strategy from the starting position. Otherwise, the line is to contain "NO". The following shows sample input and output for two test cases.

Sample Input

2
4
2 5 3 0
3
0 0 0

Sample Output

YES
NO

题目的叙述大概是：有N个点连成一个环，每两个点之间的权值给出，至少一条边的权值为0，走过一天边可以任意降低该边的权值，如果权值为0则不能走过该边，问先手是否有必胜策略。

先手有必胜策略的条件是顺时针或者逆时针，存在奇数个权值不为0的边，先手的策略是走过一条边把该权值降为0，后手只能严一个方向前进，后手如果继续把边权值降为0，则先手继续向前讲边降为0，因为只有奇数个这样的边，所以先手必胜，而如果后手不把走过的边的权值降为0，则先手向回走讲该边权值变为0.

感觉代码实现实际上用不到深搜，我只是顺时针跟逆时针都判断了一下是否有奇数个0，用循环应该也可以实现[code]#include<iostream>
using namespace std;
int a[30],b[30];
int n;
int dfs(int w,int cnt){
    if(a[w]==0||w>=n)return cnt;
    return dfs(w+1,cnt+1);
}
int dfsb(int w,int cnt){
    if(b[w]==0||w>=n)return cnt;
    return dfsb(w+1,cnt+1);
}
int main(){
    int T;
    cin>>T;
    while(T--){
        cin>>n;
        for(int i=0;i<n;i++)
            {
                cin>>a[i];
                b[n-i-1]=a[i];
            }
        if(dfs(0,0)%2||dfsb(0,0)%2)cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
}

[/code]