Problem B. Fairies and Witches Google Kickstart Round C 2018

题意：给定一堆stick（including endpoints and length），从中抽取一个subset组成凸多边形，要求subset中的endpoints不能重合。问有多少种组合。

这一题开始除了暴力没啥想法。。瞎写了个搜索，枚举所有组合（是否选择stick i）在除去不符合条件的，后来发现stick的个数是O(N^2)不是N，就呵呵了。

其实正解也是搜索，不过要在每个branch开始前略过不满足条件（endpoints重合）的branch。避免无用的枚举。

假设有M个stick，endpoints不重合的组合最多的case是所有stick一字排开，这样重合的stick最少，e.g.,(1,2),(2,3),(3,4),(4,5),...这种case下，至多可同时选择M/2个stick满足endpoints不重合的条件，所以subset个数f(M)=(M-1)*(M-3)*..*1。(or M*(M-2)*..*2?)

考虑所有的subset with different size i，组合数的Upper bound=sum C(M,i)f(i)。不过sample solution说i is even就不知道为啥了。。

判断一堆线段能否构成convex polygon，画个图看一看出来，for all i, length of stick i >sum of length of stick j, j!=i. 其实可以用一个constraint替代: max length of stick > sum of legth of other sticks.

实现code的时候纠结dfs何时退出。。如果是枚举所有组合，枚举到第M个stick退出即可。但是在正解中，搜索时只在endpoint满足条件的情况下才开启新的branch搜索。。本来以为加一个分支跳过当前stick即可，但是这样会出现重复的subset。

看到了别人的blog才发现，只要在dfs开始判断当前选择的subset是否符合条件即可。因为dfs分支中只会加入endpoint valid的stick，每个subset只会出现一次。e.g.,不会出现 select stick 0, select stick 1, not select stick 2, not select stick 3的情况。

另外，快速判断stick endpoints是否满足条件可以传入mask数组。通过或运算即可：mask|x|y，x,y是新选择的stick的两个端点。

#include<iostream>
#include<stdio.h>
#include<cstdio>
#include<string>
#include<cmath>
#include<stdlib.h>
#include<algorithm>
#include<string.h>
#include<cstring>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<windows.h>
using namespace std;

const int maxn=20;
int N;
int T;
int mp[maxn][maxn];
int ans;
int M;
int decision[110];
class stick
{
public:
    int id;
    int len;
    int a;
    int b;
    stick()
    {
        id=0;
        len=0;
        a=0;
        b=0;
    }
    stick(int idd,int lenn,int aa,int bb)
    {
        id=idd;
        len=lenn;
        a=aa;
        b=bb;
    }
};
stick arr[110];
void dfs_small(int curr)
{
    if(curr==M)
    {
        int cnt=0;

        for(int i=0;i<M;i++)
        {
            if(decision[i]==1) cnt++;
            //cout<<decision[i]<<" ";
        }
//        cout<<endl;
//        ans++;
//        return;
        //check legal
        int vertex[maxn];
        memset(vertex,0,sizeof(vertex));
        bool flg=true;
        for(int i=0;i<M;i++)
        {
            if(decision[i]==1)
            {
                //cout<<arr[i].a<<" "<<arr[i].b<<endl;
                vertex[arr[i].a]++;
                vertex[arr[i].b]++;
                //cout<<"after add "<<vertex[arr[i].a]<<" "<<vertex[arr[i].b]<<endl;
                if((vertex[arr[i].a]>1)||(vertex[arr[i].b]>1))
                {
                    flg=false;
                    break;
                }
                //cnt++;
            }
        }
        if(cnt<3) flg=false;
        //cout<<flg<<endl;
        if(flg==true)
        {
            bool flg2=true;
            for(int first=0;first<M;first++)
            {
                if(decision[first]==0) continue;
                int sum=0;
                for(int i=0;i<M;i++)
                {
                    if(i==first) continue;
                    if(decision[i]==1)
                    {
                        sum+=arr[i].len;
                    }
                }
                if(sum<=arr[first].len)
                {
                    flg2=false;
                    break;
                }
            }

            if(flg2==true)
            {
                ans++;
                return;
            }
            else
            {
                return;
            }

        }
        return;
    }
    else
    {
        decision[curr]=0;
        dfs_small(curr+1);//should avoid invalid branch here
        decision[curr]=1;
        dfs_small(curr+1);
    }

}
int bit(int mask,int i)
{
  return (mask>>i)&1;
}
void dfs(int mask,int curr)
{
    int cnt=0;
    for(int i=0;i<M;i++)
    {
        if(decision[i]==1)
        {
//            cout<<i<<" ";
            cnt++;
        }
    }
//    cout<<endl;
//    cout<<cnt<<endl;
    if(cnt>=3)
    {
        int max_len=0;
        int sum=0;
        for(int i=0;i<M;i++)
        {
            if(decision[i]==0)
            {
                continue;
            }
            max_len=max(max_len,arr[i].len);
            sum+=arr[i].len;
        }
        if(sum>max_len*2)
        {
            ans+=1;
        }

    }
    for(int i=curr;i<M;i++)
    {
        int x=arr[i].a;
        int y=arr[i].b;
//        cout<<"mask "<<mask<<" x "<<x<<" y "<<y<<" "<<bit(mask,x)<<" "<<bit(mask,y)<<endl;
        if(bit(mask,x)==0&&bit(mask,y)==0)
        {
            decision[i]=1;
//            cout<<"curr "<<curr<<" next "<<i<<" mask "<<mask<<endl;
            dfs(mask|(1<<x)|(1<<y),i+1);
            decision[i]=0;
//            dfs(mask,i+1);//skip the valid stick i
        }
    }
//    dfs(mask,curr+1);
}
int main()
{
//    freopen("input.txt","r",stdin);
    freopen("B-large-practice.in","r",stdin);
    freopen("B.txt","w",stdout);
    cin>>T;
    for(int ca=1;ca<=T;ca++)
    {
        scanf("%d",&N);
        memset(mp,0,sizeof(mp));
        //memset(arr,0,sizeof(arr));
        memset(decision,0,sizeof(decision));
        int idx=0;
        M=0;
        ans=0;
//        cerr<<"start case "<<ca<<endl;
//        cerr<<"N "<<N<<endl;
        for(int i=0;i<N;i++)
        {
            for(int j=0;j<N;j++)
            {
//                cerr<<i<<" "<<j<<endl;
                scanf("%d",&mp[i][j]);
                if(mp[i][j]!=0&&i<j)
                {
                    stick tmp=stick(idx,mp[i][j],i,j);
                    arr[idx++]=tmp;
                }
            }
        }
        M=idx;
        cerr<<M<<endl;
//        cout<<"here "<<M<<endl;
//        for(int i=0;i<M;i++)
//        {
//            cout<<"id "<<arr[i].id<<" len "<<arr[i].len<<" a "<<arr[i].a<<" b "<<arr[i].b<<endl;
//        }

        dfs(0,0);
        printf("Case #%d: %d\n", ca, ans);
        cerr<<"finish case "<<ca<<endl;

    }
    return 0;
}