第八届福建省省赛重现 7/12 待补

PDF

 

总题来说这次我们发挥的还不错吧,第一次我们三个人都充分发挥了作用,最后做出来6个题,虽然中间有很多插曲,但是还是发现我们在算法上的欠缺,继续加油！

 

Problem A Frog

 

 

签到题,队友说是鸡兔同笼问题. fzu上代码看不了,而我未保存...

 

 

 

Problem B Triangles

 

计算几何模板题,就是让你判断两个三角形的关系,相离.相交.包含....

 

队友写的模板,只需要首先枚举一个三角形三个点,去判断是否在另一个三角形内,在反过来判断,如果三点都在

就是包含,然后判断相交的情况,相交的情况就想简单的当时,只想到要判断至少有一个点在三角形内,谁知道最后少考虑了六芒星那种情况的,最后还是队友想到了才ac。判断完相交了剩下的就是相离了.

 

 

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <map>
using namespace std;
const double eps = 1e-6;
int sgn(double x)
{
    if(fabs(x) < eps)return 0;
    if(x < 0)return -1;
    else return 1;
}
struct Point
{
    double x,y;
    Point(){}
    Point(double _x,double _y)
    {
        x = _x;y = _y;
    }
    Point operator -(const Point &b)const
    {
        return Point(x - b.x,y - b.y);
    }
    //叉积
    double operator ^(const Point &b)const
    {
        return x*b.y - y*b.x;
    }
    //点积
    double operator *(const Point &b)const
    {
        return x*b.x + y*b.y;
    }
    //绕原点旋转角度B（弧度值），后x,y的变化
    void transXY(double B)
    {
        double tx = x,ty = y;
        x = tx*cos(B) - ty*sin(B);
        y = tx*sin(B) + ty*cos(B);
    }
};
struct Line
{
    Point s,e;
    Line(){}
    Line(Point _s,Point _e)
    {
        s = _s;e = _e;
    }
    //两直线相交求交点
    //第一个值为0表示直线重合，为1表示平行，为0表示相交,为2是相交
    //只有第一个值为2时，交点才有意义
    pair<int,Point> operator &(const Line &b)const
    {
        Point res = s;
        if(sgn((s-e)^(b.s-b.e)) == 0)
        {
            if(sgn((s-b.e)^(b.s-b.e)) == 0)
                return make_pair(0,res);//重合
            else return make_pair(1,res);//平行
        }
        double t = ((s-b.s)^(b.s-b.e))/((s-e)^(b.s-b.e));
        res.x += (e.x-s.x)*t;
        res.y += (e.y-s.y)*t;
        return make_pair(2,res);
    }
};

//判断线段相交
bool inter(Line l1,Line l2)
{
    return
    max(l1.s.x,l1.e.x) >= min(l2.s.x,l2.e.x) &&
    max(l2.s.x,l2.e.x) >= min(l1.s.x,l1.e.x) &&
    max(l1.s.y,l1.e.y) >= min(l2.s.y,l2.e.y) &&
    max(l2.s.y,l2.e.y) >= min(l1.s.y,l1.e.y) &&
    sgn((l2.s-l1.e)^(l1.s-l1.e))*sgn((l2.e-l1.e)^(l1.s-l1.e)) <= 0 &&
    sgn((l1.s-l2.e)^(l2.s-l2.e))*sgn((l1.e-l2.e)^(l2.s-l2.e)) <= 0;
}

//判断点在线段上
//判断点在线段上
bool OnSeg(Point P,Line L)
{
    return
    sgn((L.s-P)^(L.e-P)) == 0 &&
    sgn((P.x - L.s.x) * (P.x - L.e.x)) <= 0 &&
    sgn((P.y - L.s.y) * (P.y - L.e.y)) <= 0;
}
//判断点在凸多边形内
//点形成一个凸包，而且按逆时针排序（如果是顺时针把里面的<0改为>0）
//点的编号:0~n-1
//返回值：
//-1:点在凸多边形外
//0:点在凸多边形边界上
//1:点在凸多边形内
int inConvexPoly(Point a,Point p[],int n)
{
    for(int i = 0;i < n;i++)
    {
        if(sgn((p[i]-a)^(p[(i+1)%n]-a)) < 0)return -1;
        else if(OnSeg(a,Line(p[i],p[(i+1)%n])))return 0;
    }
    return 1;
}
//判断点在任意多边形内
//射线法，poly[]的顶点数要大于等于3,点的编号0~n-1
//返回值
//-1:点在凸多边形外
//0:点在凸多边形边界上
//1:点在凸多边形内
int inPoly(Point p,Point poly[],int n)
{
    int cnt;
    Line ray,side;
    cnt = 0;
    ray.s = p;
    ray.e.y = p.y;
    ray.e.x = -100000000000.0;//-INF,注意取值防止越界

    for(int i = 0;i < n;i++)
    {
        side.s = poly[i];
        side.e = poly[(i+1)%n];

        if(OnSeg(p,side))return 0;

        //如果平行轴则不考虑
        if(sgn(side.s.y - side.e.y) == 0)
            continue;

        if(OnSeg(side.s,ray))
        {
            if(sgn(side.s.y - side.e.y) > 0)cnt++;
        }
        else if(OnSeg(side.e,ray))
        {
            if(sgn(side.e.y - side.s.y) > 0)cnt++;
        }
        else if(inter(ray,side))
            cnt++;
    }
    if(cnt % 2 == 1)return 1;
    else return -1;
}
int main()
{
    int t;
    cin >> t;
    int x1, x2, x3, x4, x5, x6, y1,y2,y3,y4,y5,y6;
    while(t--)
    {
        scanf("%d%d%d%d%d%d", &x1, &y1, &x2, &y2, &x3, &y3);
        scanf("%d%d%d%d%d%d", &x4, &y4, &x5, &y5, &x6, &y6);
        Point p1[10], p2[10];
        p1[0] = Point(x1, y1);
        p1[1] = Point(x2, y2);
        p1[2] = Point(x3, y3);
        p2[0] = Point(x4, y4);
        p2[1] = Point(x5, y5);
        p2[2] = Point(x6, y6);
        int flag = 0;
        if(inPoly(p1[0], p2, 3) == 1 &&  inPoly(p1[1], p2, 3) == 1 && inPoly(p1[2], p2, 3) == 1)
            flag = 1;
        if(inPoly(p2[0], p1, 3) == 1 &&  inPoly(p2[1], p1, 3) == 1 && inPoly(p2[2], p1, 3) == 1)
            flag = 1; // limian
        for(int i = 0; i < 3; i++)
        {
            for(int j = i; j < 3; j++)
            {
                Line l1 = Line(p1[i], p1[j]);
                for(int x = 0; x < 3; x++)
                {
                    for(int y = x; y < 3; y++)
                    {
                        Line l2 = Line(p2[x], p2[y]);
                        if(inter(l1, l2))
                            flag = 2;

                    }
                }
            }
        }
        if(flag == 1)
            puts("contain");
        else if(flag == 2)
            puts("intersect");
        else
            puts("disjoint");

    }
    return 0;
}
/*
10
4 3 7 3 7 6
5 2 5 10 6 10
*/

 

 

 

 

 

Problem C DotA and LOL

 

 

 

Problem D Game

 

 

给你两个大数,(不含前导零), 
两个人轮流操作自己的数,可以除以10(向下取整,没有小数.)或者翻转过去,(翻转之后要去掉前导0).

当有一时刻两个数相等则A赢,否则B赢,所以A想要将两个数变得相同,B想讲两个数变得不同.

问你两个人最后谁赢？

 

 

可以考虑一下,因为每一轮每人必须要对自己的数进行一次操作,直到最后为0,也一直在进行,一直是0了.

所以我们可以想到,如果当前B不能在A中正着匹配,或者反着匹配,那么无论A怎么变我B就一直翻转我的数,那你永远

也别想赢.否则如果A中有B的子串,那你B无论怎么办,总有一个A==B  ,上面也说了即使除到0,最后就真的一直是0

俩人都是0也匹配了.
 

另外需要注意,如果一开始B后面有0,需要将B中的后缀0 全部去掉,在跟A进行匹配.但是A中后面的0对结果无影响.

举例: 1235 120 

 

代码也没带出来....可以看这个 D

 

 

Problem E Doctor

 

 

 

 

Problem F Change

 

 

题意:

 

 

有一个根为1的有根树

然后有两种操作 
1 v x k : a[v]+=x , a[v’]+=x-k (v’是v的孩子) , a[v”]+=x-2*k (v”是v’的孩子) and so on. 
2 v : 输出 a[v] mod 1000000007(10^9 + 7).

 

思路:

 

 

对于根节点为V的子树中的每一个结点i, a[i]=x-(deep[i]-deep[v])*k,展开之后为 a[i]=x+deep[v]*k-k*deep[i]。 我们可以发现,对于每一个结点都会有x+deep[v]*k ,变化的只有k*deep[i] .而deep[i]又是固定不变的,所以我们这里要用到两个BIT，一个维护以v为根节点的子树中k的变化,然后再维护一个 x+deep[v]*k的和.当查询第w个结点的时候,我们只要求出对于该节点的x+deep[v]*k的变化,再求出k的变化乘以deep[w]，做差就可以得到该点值的变化,

当然这个过程需要用dfs序来实现.

 

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int maxn=3e5+10;
int t,n,q;
int in[maxn],out[maxn],deep[maxn];
vector<int>vt[maxn];
int cnt;
struct node
{	
	
	ll s[maxn];
	void init()
	{
		memset(s,0,sizeof(s));
	}
	int lowbit(int x)
	{
		return x&-x;
	}
	void add(int x,ll d)
	{
		while(x<maxn)
		{
			s[x]+=d;
			x+=lowbit(x);
		}
		return ;
	}
	ll sum(int x)
	{
		ll res=0;
		while(x)
		{
			res+=s[x];
			x-=lowbit(x);
		}
		return res;
	}
}b1,b2;
void dfs(int x,int d,int pre)
{
	in[x]=++cnt;
	deep[x]=d;
	for(int i=0;i<vt[x].size();i++)
	{
		int v=vt[x][i];
		if(v==pre)
		continue;
		dfs(v,d+1,x);
	}
	out[x]=cnt;
}
int main(){

	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
		vt[i].clear();
		b1.init();
		b2.init();
		ll x;
		for(int i=2;i<=n;i++)
		{
			scanf("%d",&x);
			vt[x].push_back(i);
			vt[i].push_back(x);
		}
		cnt=0;
		memset(deep,0,sizeof(deep));
		dfs(1,0,-1);
		scanf("%d",&q);
		ll op,v,k;
		while(q--)
		{
			scanf("%I64d %I64d",&op,&v);
			if(op==1)
			{
				scanf("%I64d%I64d",&x,&k);
				x+=k*deep[v];
				x%=mod;
				b1.add(in[v],x);
				b1.add(out[v]+1,-x);
				b2.add(in[v],k);
				b2.add(out[v]+1,-k);
			}
			else
			{
				ll ans=b1.sum(in[v]);
				ll res=b2.sum(in[v]);
				ans=(ans-(ll )res*deep[v]%mod+mod)%mod;
				printf("%I64d\n",ans);
			}
		}
	}
	return 0;
}

 

 

 

 

 

Problem G YYS

 

就是有一个人,要集齐n张卡,每个卡出现的概率都为1/n，他每隔w天可以买一次卡,问你集齐所有卡片的期望是多少.

 

特别特别好的一个数学期望的题目!

 

这个题目可以参考我这个队友的博客  要不是这个题做过可能就炸掉了

 

这个题的话就是一定不要对n个球星去单独的考虑,而是要考虑如何去增加一名球星.

试想一下,我初始时买第一个球星的概率是1,（也就是我随便抽一个球星,这个球星都是我目前没有的）,然后我要获得第二个球星（我现在手中没有的）的概率是（n-1）/n ,第三个就是（n-2）/n。 又因为期望就是反应随机变量的平均取值大小的,所以我们考虑这个题目我们先求出要取得次数乘以W就可以了, 那么对于第一个球星,我们平均取一次就可以得到它,对于第二个我们用1/概率就是次数,也就是要平均取 n/(n-1) 次....以此类推.最后一个需要取n次才可以.于是得到  ans=（1+n/(n-1)+n/(n-2)+n/(n-3)+.....n）*w= n!/i  i=1,2,3...n 。

 

因为n最大为3000,我们还特意试了java 存不下...只能自己写了.

 

所以这题最后就是数学期望+大数模板.

 

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cmath>
#include <stack>
#include <cstring>
using namespace std;
//const int maxn = 1e6;  //大数位数
#define MAXN 9999
#define MAXSIZE 10
#define DLEN 4

class BigNum
{
private:
    int a[MAXN];    //可以控制大数的位数
    int len;       //大数长度
public:
    BigNum(){ len = 1;memset(a,0,sizeof(a)); }   //构造函数
    BigNum(const int);       //将一个int类型的变量转化为大数
    BigNum(const char*);     //将一个字符串类型的变量转化为大数
    BigNum(const BigNum &);  //拷贝构造函数
    BigNum &operator=(const BigNum &);   //重载赋值运算符，大数之间进行赋值运算

    friend istream& operator>>(istream&,  BigNum&);   //重载输入运算符
    friend ostream& operator<<(ostream&,  BigNum&);   //重载输出运算符

    BigNum operator+(const BigNum &) const;   //重载加法运算符，两个大数之间的相加运算
    BigNum operator-(const BigNum &) const;   //重载减法运算符，两个大数之间的相减运算
    BigNum operator*(const BigNum &) const;   //重载乘法运算符，两个大数之间的相乘运算
    BigNum operator/(const int   &) const;    //重载除法运算符，大数对一个整数进行相除运算

    BigNum operator^(const int  &) const;    //大数的n次方运算
    int    operator%(const int  &) const;    //大数对一个int类型的变量进行取模运算
    bool   operator>(const BigNum & T)const;   //大数和另一个大数的大小比较
    bool   operator<(const BigNum & T) const;
    bool   operator==(const BigNum & T) const;
    bool   operator>(const int & t)const;      //大数和一个int类型的变量的大小比较
    bool   operator<(const int &t) const;
    bool   operator==(const int &t) const;

    void print();       //输出大数
};

bool BigNum::operator==(const BigNum & T) const {
    return !(*this > T) && !(T > *this);
}
bool BigNum::operator==(const int &t) const {
    BigNum T = BigNum(t);
    return *this == T;
}
bool BigNum::operator<(const BigNum & T) const {
    return T > *this;
}
bool BigNum::operator<(const int &t) const {
    return BigNum(t) > *this;
}
BigNum::BigNum(const int b)     //将一个int类型的变量转化为大数
{
    int c,d = b;
    len = 0;
    memset(a,0,sizeof(a));
    while(d > MAXN)
    {
        c = d - (d / (MAXN + 1)) * (MAXN + 1);
        d = d / (MAXN + 1);
        a[len++] = c;
    }
    a[len++] = d;
}
BigNum::BigNum(const char*s)     //将一个字符串类型的变量转化为大数
{
    int t,k,index,l,i;
    memset(a,0,sizeof(a));
    l=strlen(s);
    len=l/DLEN;
    if(l%DLEN)
        len++;
    index=0;
    for(i=l-1;i>=0;i-=DLEN)
    {
        t=0;
        k=i-DLEN+1;
        if(k<0)
            k=0;
        for(int j=k;j<=i;j++)
            t=t*10+s[j]-'0';
        a[index++]=t;
    }
}
BigNum::BigNum(const BigNum & T) : len(T.len)  //拷贝构造函数
{
    int i;
    memset(a,0,sizeof(a));
    for(i = 0 ; i < len ; i++)
        a[i] = T.a[i];
}
BigNum & BigNum::operator=(const BigNum & n)   //重载赋值运算符，大数之间进行赋值运算
{
    int i;
    len = n.len;
    memset(a,0,sizeof(a));
    for(i = 0 ; i < len ; i++)
        a[i] = n.a[i];
    return *this;
}
istream& operator>>(istream & in,  BigNum & b)   //重载输入运算符
{
    char ch[MAXSIZE*4];
    int i = -1;
    in>>ch;
    int l=strlen(ch);
    int count=0,sum=0;
    for(i=l-1;i>=0;)
    {
        sum = 0;
        int t=1;
        for(int j=0;j<4&&i>=0;j++,i--,t*=10)
        {
            sum+=(ch[i]-'0')*t;
        }
        b.a[count]=sum;
        count++;
    }
    b.len =count++;
    return in;

}
ostream& operator<<(ostream& out,  BigNum& b)   //重载输出运算符
{
    int i;
    cout << b.a[b.len - 1];
    for(i = b.len - 2 ; i >= 0 ; i--)
    {
        cout.width(DLEN);
        cout.fill('0');
        cout << b.a[i];
    }
    return out;
}

BigNum BigNum::operator+(const BigNum & T) const   //两个大数之间的相加运算
{
    BigNum t(*this);
    int i,big;      //位数
    big = T.len > len ? T.len : len;
    for(i = 0 ; i < big ; i++)
    {
        t.a[i] +=T.a[i];
        if(t.a[i] > MAXN)
        {
            t.a[i + 1]++;
            t.a[i] -=MAXN+1;
        }
    }
    if(t.a[big] != 0)
        t.len = big + 1;
    else
        t.len = big;
    return t;
}
BigNum BigNum::operator-(const BigNum & T) const   //两个大数之间的相减运算
{
    int i,j,big;
    bool flag;
    BigNum t1,t2;
    if(*this>T)
    {
        t1=*this;
        t2=T;
        flag=0;
    }
    else
    {
        t1=T;
        t2=*this;
        flag=1;
    }
    big=t1.len;
    for(i = 0 ; i < big ; i++)
    {
        if(t1.a[i] < t2.a[i])
        {
            j = i + 1;
            while(t1.a[j] == 0)
                j++;
            t1.a[j--]--;
            while(j > i)
                t1.a[j--] += MAXN;
            t1.a[i] += MAXN + 1 - t2.a[i];
        }
        else
            t1.a[i] -= t2.a[i];
    }
    t1.len = big;
    while(t1.a[t1.len - 1] == 0 && t1.len > 1)
    {
        t1.len--;
        big--;
    }
    if(flag)
        t1.a[big-1]=0-t1.a[big-1];
    return t1;
}

BigNum BigNum::operator*(const BigNum & T) const   //两个大数之间的相乘运算
{
    BigNum ret;
    int i,j,up;
    int temp,temp1;
    for(i = 0 ; i < len ; i++)
    {
        up = 0;
        for(j = 0 ; j < T.len ; j++)
        {
            temp = a[i] * T.a[j] + ret.a[i + j] + up;
            if(temp > MAXN)
            {
                temp1 = temp - temp / (MAXN + 1) * (MAXN + 1);
                up = temp / (MAXN + 1);
                ret.a[i + j] = temp1;
            }
            else
            {
                up = 0;
                ret.a[i + j] = temp;
            }
        }
        if(up != 0)
            ret.a[i + j] = up;
    }
    ret.len = i + j;
    while(ret.a[ret.len - 1] == 0 && ret.len > 1)
        ret.len--;
    return ret;
}
BigNum BigNum::operator/(const int & b) const   //大数对一个整数进行相除运算
{
    BigNum ret;
    int i,down = 0;
    for(i = len - 1 ; i >= 0 ; i--)
    {
        ret.a[i] = (a[i] + down * (MAXN + 1)) / b;
        down = a[i] + down * (MAXN + 1) - ret.a[i] * b;
    }
    ret.len = len;
    while(ret.a[ret.len - 1] == 0 && ret.len > 1)
        ret.len--;
    return ret;
}
int BigNum::operator %(const int & b) const    //大数对一个int类型的变量进行取模运算
{
    int i,d=0;
    for (i = len-1; i>=0; i--)
    {
        d = ((d * (MAXN+1))% b + a[i])% b;
    }
    return d;
}
BigNum BigNum::operator^(const int & n) const    //大数的n次方运算
{
    BigNum t,ret(1);
    int i;
    if(n<0)
        exit(-1);
    if(n==0)
        return 1;
    if(n==1)
        return *this;
    int m=n;
    while(m>1)
    {
        t=*this;
        for( i=1;i<<1<=m;i<<=1)
        {
            t=t*t;
        }
        m-=i;
        ret=ret*t;
        if(m==1)
            ret=ret*(*this);
    }
    return ret;
}
bool BigNum::operator>(const BigNum & T) const   //大数和另一个大数的大小比较
{
    int ln;
    if(len > T.len)
        return true;
    else if(len == T.len)
    {
        ln = len - 1;
        while(a[ln] == T.a[ln] && ln >= 0)
            ln--;
        if(ln >= 0 && a[ln] > T.a[ln])
            return true;
        else
            return false;
    }
    else
        return false;
}
bool BigNum::operator >(const int & t) const    //大数和一个int类型的变量的大小比较
{
    BigNum b(t);
    return *this>b;
}

void BigNum::print()    //输出大数
{
    int i;
    printf("%d", a[len-1]);
    for (int i = len-2; i >= 0; --i) {
        printf("%04d", a[i]);
    }
}

int main()
{
    int t, n;
    cin >> t;
    while(t--)
    {
        scanf("%d", &n);
        BigNum cnt = 1, ans = 0;
        for(int i = 1; i <= n; i++)
        {
            cnt = cnt * i;
        };
        for(int i = 1; i <= n; i++)
        {
            ans = ans + cnt/i;;
            BigNum tmp = (cnt/i);
        }
        ans.print();
        printf(".0\n");
    }
    return 0;
}

 

 

 

Problem H Cantonese

 

 

 

 

Problem I Magic

 

Problem J Trades

 

Problem K Wand

 

 

 

有n个人,每个人有一个物品,问你打乱这些物品后至少有K个人还拿到自己的物品的可能数

 

这个题的模型也不错. 我拿到这个题的时候就想到了是组合数学+错排公式,但是需要从反面想,因为k比较小,n比较小.

所以我们需要计算不满足的情况,然后用n！-不满足的得到满足的.  其实正着求解也可以过.

 

 

代码也没带出来,可以看这个 K

 

 

 

Problem L Tic-Tac-Toe

 

两个人下井字棋,现在轮到Kim下,问你Kim在下两个子的内能不能赢

 

这个是队友写的，直接暴力枚举第一次第二次Kim可以下在哪里就可以.

先看‘.’ 如果Kim下第一次就赢了,那么就赢了.

如果下一次赢不了,那么就要保证Kim下完一次后必须有两处或两处以上的地方能保证Kim在下一次就赢,否则对方还是会阻断你赢.直接枚举所有‘.’依次作为下的地方判断就可以.

 

 

#include<stdio.h>
#include<string.h>
#include<math.h>
using namespace std;
#define LL long long int

const int N = 1e5 + 7;
const int MOD = 1e9+7;

/**********************************/

int a[10][10];

void display(){
    for(int i=1;i<=3;i++){
        for(int j=1;j<=3;j++)
            printf("%d ",a[i][j]);
        puts("");
    }
    puts(" <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
}

bool judge(int x){
//    printf("%d\n",x);
//    display();
    if(x==a[1][1]&&a[1][1]==a[1][2]&&a[1][2]==a[1][3])return true;
    if(x==a[2][1]&&a[2][1]==a[2][2]&&a[2][2]==a[2][3])return true;
    if(x==a[3][1]&&a[3][1]==a[3][2]&&a[3][2]==a[3][3])return true;

    if(x==a[1][1]&&a[1][1]==a[2][1]&&a[2][1]==a[3][1])return true;
    if(x==a[1][2]&&a[1][2]==a[2][2]&&a[2][2]==a[3][2])return true;
    if(x==a[1][3]&&a[1][3]==a[2][3]&&a[2][3]==a[3][3])return true;

    if(x==a[1][1]&&a[1][1]==a[2][2]&&a[2][2]==a[3][3])return true;
    if(x==a[1][3]&&a[1][3]==a[2][2]&&a[2][2]==a[3][1])return true;
//    puts("--");
    return false;
}

bool Kim2(int x){
    int flag = 0;
    for(int i=1;i<=3;i++){
        for(int j=1;j<=3;j++){
            if(a[i][j]==0){
                a[i][j]=x;
                if(judge(x)) flag++;
                a[i][j]=0;
            }
        }
    }
    return flag>=2;
}

bool Kim1(int x){
    for(int i=1;i<=3;i++){
        for(int j=1;j<=3;j++){
            if(a[i][j]==0){
                a[i][j]=x;
                if(judge(x)||Kim2(x))
                    return true;
                a[i][j]=0;
            }
        }
    }
    return false;
}

char s[10];
int main(){
    int _ = 1,kcase = 0;
    for(scanf("%d",&_);_--;){

        for(int i=1;i<=3;i++){
            for(int j=1;j<=3;j++){
                scanf("%s",s);
                if(s[0]=='.') a[i][j]=0;
                else if(s[0]=='x') a[i][j]=1;
                else a[i][j]=2;
            }
        }

        scanf("%s",s);int x;
        if(s[0]=='x')   x=1;
        else            x=2;

        if(judge(3-x)) puts("Cannot win!");
        else if(judge(x)||Kim1(x))
             puts("Kim win!");
        else puts("Cannot win!");
    }
    return 0;
}