【8.22校内测试】【数学】【并查集】【string】

今天的t2t3能打出来80分的暴力都好满足啊QwQ。(%%%$idy$

今天的签到题，做的时候一眼就看出性质叻qwq。大于11的所有数分解合数都可以用4、6、9表示，乱搞搞就可以了。

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

void read ( int &x ) {
    x = 0; char ch = getchar ( );
    while ( ch > '9' || ch < '0' ) ch = getchar ( );
    while ( ch >= '0' && ch <= '9' ) {
        x = x * 10 + ch - '0'; ch = getchar ( );
    }
}

int main ( ) {
    freopen ( "split.in", "r", stdin );
    freopen ( "split.out", "w", stdout );
    int T;
    scanf ( "%d", &T );
    while ( T -- ) {
        int n;
        read ( n );
        int t = n / 2, qwq = n % 2;
        if ( t < 2 ) {
            printf ( "-1
" );
        } else if ( t % 2 == 0 && qwq == 0 ) {
            printf ( "%d
", t / 2 );
        } else if ( t % 2 == 0 && qwq ) {
            if ( n == 5 ) {
                printf ( "-1
" );    
            } else if ( t <= 4 ) {
                printf ( "1
" );
            } else printf ( "%d
", t / 2 - 1 );
        } else if ( t % 2 && qwq == 0 ) {
            printf ( "%d
", t / 2 );
        } else if ( t % 2 && qwq ) {
            if ( n < 15 ) {
                printf ( "-1
" );
            } else {
                printf ( "%d
", ( t - 7 ) / 2 + 2 );
            }
        }
    }
    return 0;
}

$yuli$（%%%a掉的一道神题！（至今不理解dalao的思维方式QwQ

好不容易搞懂了$idy$的解释！是一种很巧妙的理解方法。我们把所有的点的横纵坐标之间连边，构成了下图所示的多个连通图：

实际上图中的每条边就相当于每个点了，每条边可以选择管辖一个点，就是原问题中的一条直线。我们把所有有关系的点建成如上图所示（区分一下x和y坐标），可以发现，不在同一个联通块之间的点（原图中的直线）就永远不会互相影响。所以我们只用计算每个联通块的方案数，用乘法原理即可。

每个联通块又分为两种情况，第一种是如上图的树形结构。【一下的边和点都指建出的新图中的边和点】即边数小于点数，最大的覆盖只能是边数。如下图：

最少都会不能覆盖到一个点。又因为每条边我们可以选择管辖点或者不管辖，所以设点数是$size$，$size-1$的所有子集都可以达到。此时方案数为$2^{size-1}$。

另一种情况，就是样例二中多个点相互重叠影响，如下图：

我们可以发现，只要出现了这种情况，整个点集都可以被覆盖，如下图：

而所有方案的子集也都能达到，所以此时的方案数是$2^{size}$。

有了以上的理解，我们就可以愉快地建图计算辣~维护一个并查集的$size$，表示当前联通块的点数，建边过后跑$dfs$，标记联通块中的点并判断是否有环。答案累乘即可。【注意】原图中点的坐标需要离散化。

#include<iostream>
#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;

const int mod = 1e9 + 7;

int n;

ll mpow ( ll a, ll b ) {
    ll ans = 1;
    for ( ; b; b >>= 1, a = a * a % mod )
        if ( b & 1 ) ans = ans * a % mod;
    return ans;
}

int stot, nex[800005], tov[800005], h[400005];
void add ( int u, int v ) {
    tov[++stot] = v;
    nex[stot] = h[u];
    h[u] = stot;
}

struct node {
    int x, y;
} poi[100005];

bool vis[400005], flag;
void dfs ( int u, int f ) {
    vis[u] = 1;
    for ( int i = h[u]; i; i = nex[i] ) {
        int v = tov[i];
        if ( v == f ) continue;
        if ( vis[v] ) { flag = 1; continue; }
        dfs ( v, u );
    }
}

int fa[400005], siz[400005];
int find ( int x ) {
    if ( fa[x] != x ) return fa[x] = find ( fa[x] );
    return x;
}

void unionn ( int x, int y ) {
    int xx = find ( x ); int yy = find ( y );
    fa[xx] = yy;
    siz[yy] += siz[xx];
}

ll x[100005], y[100005];
int main ( ) {
    freopen ( "cross.in", "r", stdin );
    freopen ( "cross.out", "w", stdout );
    scanf ( "%d", &n );
    for ( int i = 1; i <= n; i ++ ) {
        scanf ( "%I64d%I64d", &x[i], &y[i] );
        poi[i].x = x[i]; poi[i].y = y[i];
    }
    sort ( x + 1, x + 1 + n );
    sort ( y + 1, y + 1 + n );
    int m = unique ( x + 1, x + 1 + n ) - x - 1;
    int k = unique ( y + 1, y + 1 + n ) - y - 1;
    for ( int i = 1; i <= n; i ++ ) {
        poi[i].x = lower_bound ( x + 1, x + 1 + m, poi[i].x ) - x;
        poi[i].y = lower_bound ( y + 1, y + 1 + k, poi[i].y ) - y + n;
    }
    for ( int i = 1; i <= n; i ++ ) {
        int xx = poi[i].x, yy = poi[i].y;
        fa[xx] = xx; fa[yy] = yy; siz[xx] = siz[yy] = 1;
    }
    for ( int i = 1; i <= n; i ++ ) {
        int xx = poi[i].x, yy = poi[i].y;
        add ( xx, yy );
        add ( yy, xx );
        if ( find ( xx ) != find ( yy ) )
            unionn ( xx, yy );
    }
    ll ans = 1;
    for ( int i = 1; i <= n; i ++ ) {
        int xx = poi[i].x;
        if ( !vis[xx] ) {
            flag = 0;
            dfs ( xx, 0 );
            int size = siz[find ( xx )];
            if ( flag ) {
                ans = ans * mpow ( 2, (ll)size ) % mod;
            } else {
                ans = ans * ( mpow ( 2, (ll)size ) - 1 ) % mod;
            }
        }
    }
    printf ( "%I64d", ans );
    return 0;
}

看了标程惊觉$string$这个容器真是强无敌啊QwQ！比开$char$数组多了很多很方便的操作！

然后回想起考场上自己乱搞搞的哈希和暴力合并，其实感觉思路没错，就是模拟合并的操作，但是没有发现两个串合并起来，只需要判断第一个串的尾和第二个串的头$k$个字符有没有贡献就可以了！整个串又丑又长塞不下aaaQwQ

至于上面的$k$，我们可以发现，因为每个原始串中最多有$100-k+1$个长度为$k$的子串，原始最多有$100*(100-k+1)$个长度为k的子串，而每次合并两个串，最多只会增加$k$个长度为$k$的子串，最多增加$100*k$个，所以自始至终最多只会有$100*(100-k+1)+100*k$个长度为$k$的子串。而总子串数是$<=2^k$的，解出来$k<=13$（实际上11完全够了qwq。$k$非常小，我们可以把所有长度$1-11$的01串全部处理出来存在一个$stat$字符串组里面。

每次合并串的时候，我们只需要长度22就够了，所以截取前后即可。

定义$bool$数组$dp[i][j]$表示第$i$个串中是否存在我们预处理出来的第$j$个$stat$串，更新就是用$string$中的取子串操作$substr$取出两个组合的子串判断即可，如果是前$n$个串初始串暴力判断即可。

处理完$dp$数组后，直接所有串扫一遍，只要有一个长度为$p$的子串不存在，$p$就一定不是最后的解。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

const int L = 11;

int n, m, opt;
string str[210];
string stat[5005];
int son[210][2], dp[210][5005];

void init ( ) {
    for ( int l = 1; l <= L; l ++ ) {
        for ( int i = 0; i < ( 1 << l ); i ++ ) {
            ++opt;
            string &s = stat[opt];
            s.resize ( l );
            for ( int j = 0; j < l; j ++ )
                s[j] = ( char ) ( '0' + ( ( i >> j ) & 1 ) );
        }
    }
}

string merge ( string a, string b ) {
    string c;
    for( int i = 0; i < a.size ( ); i ++ )
        c.push_back( a[i] );
    for( int i = 0; i < b.size ( ); i ++ )
        c.push_back( b[i] );
    if ( c.length ( ) > 2 * L ) {
        string cc;
        for ( int i = 0; i < L; i ++ )
            cc.push_back ( c[i] );
        for ( int i = 0; i < L; i ++ )
            cc.push_back ( c[c.length ( )-L+i] );
        return cc;
    } else return c;
}

int main ( ) {
    freopen ( "string.in", "r", stdin );
    freopen ( "string.out", "w", stdout );
    ios :: sync_with_stdio ( 0 );
    init ( );
    cin >> n;
    for ( int i = 1; i <= n; i ++ )
        cin >> str[i];
    cin >> m;
    for ( int i = 1; i <= m; i ++ ) {
        int a, b;
        cin >> a >> b;
        str[i+n] = merge ( str[a], str[b] );
        son[i+n][0] = a;
        son[i+n][1] = b;
    }
    for ( int i = 1; i <= n + m; i ++ ) {
        if ( i <= n ) {
            for ( int j = 1; j <= opt; j ++ )
                for ( int k = 0; k + stat[j].size ( ) <= str[i].size ( ); k ++ )
                    if ( str[i].substr ( k, stat[j].size ( ) ) == stat[j] ) {
                        dp[i][j] = 1; break;
                    }
        } else {
            int a = son[i][0];
            int b = son[i][1];
            for ( int j = 1; j <= opt; j ++ ) {
                dp[i][j] = ( dp[a][j] || dp[b][j] );
                if ( dp[i][j] ) continue;
                for ( int l = 1; l < stat[j].size ( ); l ++ ) {
                    if ( l > str[a].length ( ) || stat[j].length ( ) - l > str[b].length ( ) ) continue;
                    if ( str[a].substr ( str[a].length ( ) - l, l ) + str[b].substr ( 0, stat[j].length ( ) - l ) == stat[j] ) {
                        dp[i][j] = 1; break;
                    }
                }
            }
        }
    }
    for ( int i = n + 1; i <= n + m; i ++ ) {
        bool ok[L+1];
        memset ( ok, 1, sizeof ( ok ) );
        for ( int j = 1; j <= opt; j ++ ) {
            if ( !dp[i][j] ) {
                ok[stat[j].length ( )] = 0;
            }
        }
        for ( int k = L; k >= 0; k -- )
            if ( ok[k] ) {
                printf ( "%d
", k );
                break;
            }
    }
    return 0;
}