AtCoder Grand Contest #026 C - String Coloring

最新推荐文章于 2025-08-09 15:58:26 发布

weixin_30764771

最新推荐文章于 2025-08-09 15:58:26 发布

阅读量109

点赞数

CC 4.0 BY-SA版权

文章标签： java c/c++

原文链接：http://www.cnblogs.com/8023spz/p/9389917.html

本文介绍了一种高效的字符串匹配算法，该算法能在O(2^n)的时间复杂度内解决特定的字符串匹配问题，通过将原始字符串分为两半并分别进行处理来降低复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Time Limit: 3 sec / Memory Limit: 1024 MB

Score : $600600$ points

Problem Statement

You are given a string $SS$ of length $2N2N$ consisting of lowercase English letters.

There are ${22N22N}^{2N22N}$ ways to color each character in $SS$ red or blue. Among these ways, how many satisfy the following condition?

The string obtained by reading the characters painted red from left to right is equal to the string obtained by reading the characters painted blue from right to left.

Constraints

$1\leqN\leq181\leqN\leq18$
The length of $SS$ is $2N2N$ .
$SS$ consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

 $NN$ 
 $SS$

Output

Print the number of ways to paint the string that satisfy the condition.

Sample Input 1 Copy

Copy

4
cabaacba

Sample Output 1 Copy

Copy

There are four ways to paint the string, as follows:

cabaacba
cabaacba
cabaacba
cabaacba

Sample Input 2 Copy

Copy

11
mippiisssisssiipsspiim

Sample Output 2 Copy

Copy

Sample Input 3 Copy

Copy

4
abcdefgh

Sample Output 3 Copy

Copy

Sample Input 4 Copy

Copy

18
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

Sample Output 4 Copy

Copy

9075135300

The answer may not be representable as a $3232$ -bit integer.

如果直接暴力是O(2^2n)的复杂度，肯定超时，测试样例就可以直接测试出超时i，所以要缩短复杂度，这道题很巧妙，可以把字符串分为两半，这样复杂度就是O(2^n)的了，为什么要分为两部分呢？

先回到题目要求，题目要求就是把字符串分为相等的两个字符串（当然不是从中部分开），一部分从左往右选取n个，一部分从右往左选取n个，这两个字符串相等。

对照第一个样例，可以设这两个字符串为a（红色）和ra（蓝色），把原字符串从中部分开，左边包含蓝色和红色，右边也包含蓝色和红色，a和ra（倒序选取的）是相等的，所以a在左边的部分等于ra在右边的部分，a在右边的部分等于ra在左边的部分，caba acba，a的左边部分是"c",ra的右边部分也是"c",a的右边部分是"aba",ra的左边部分也是"aba",其实很好想象，如果存在a和ra相等，那么一定满足这个规律，左右两半的长度都为n，a和ra的长度也为n，如果a在左边的长度as(<=n)，那么左边剩下的（n - as）个字符组成的反向字符串肯定是和a在右边的剩余部分相等的，首先长度肯定是相等，其次内容，因为a和ra都是按照顺序选取并组合的字符串，所以内容肯定也是相等的。因此可以建立一个状态pair<a,ra>，左右状态是相同的就是满足的。

这样只需要记录左边的状态，状态相同的算到一起，红色和蓝色的顺序是无关的，比如caaa acaa和caaa acaa，左边状态是相同的，所以再看右部遇到状态相同的，只需要加上左边相同状态的个数就可以了，遍历直接按照二进制位计算就可以了，区间[0,1<<n)。

c++代码：

#include <map>
#include <iostream>
using namespace std;
typedef pair<string,string> pa;
int main() {
    int n;
    long long ans = 0;
    string s;
    map<pa,int> mp;
    cin>>n>>s;
    for(int i = 0;i < 1 << n;i ++) {
        string a = "";
        string b = "";
        for(int j = 0;j < n;j ++) {
            if(i >> j & 1)a += s[j];///二进制位为1 属于a串
            else b += s[j];///二进制位为0 属于ra串
        }
        mp[pa(a,b)] ++;///记录状态个数
    }
    for(int i = 0;i < 1 << n;i ++) {
        string a = "";
        string b = "";
        for(int j = 0;j < n;j ++) {
            if(i >> j & 1)a += s[n * 2 - 1 - j];///二进制位为1 属于a串
            else b += s[n * 2 - 1 - j];///二进制位为0 属于ra串
        }
        ans += mp[pa(a,b)];///加上匹配的状态个数
    }
    cout<<ans;
}

java代码：

import java.util.*;
class Pair<V,K>{
    V first;
    K second;
    public Pair() {first = null;second = null;}
    public Pair(V f,K s){
        first = f;
        second = s;
    }
    public boolean equals(Object o) {
        if(!(o instanceof Pair))
        {
            return false;
        }
        Pair<V,K> pn = (Pair<V,K>)o;
        return pn.first.equals(first) && pn.second.equals(second);
    }
    public int hashCode() {
        return first.hashCode() + second.hashCode();
    }
}
public class Main {
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long ans = 0;
        int n = in.nextInt();
        String s = in.next();
        String aa = null,bb = null;
        Map<Pair<String,String>,Integer> map = new HashMap();
        for(int i = 0;i < 1 << n;i ++) {
            StringBuilder a = new StringBuilder();
            StringBuilder b = new StringBuilder();
            for(int j = 0;j < n;j ++) {
                if((i >> j) % 2 == 1)a.append(s.charAt(j));
                else b.append(s.charAt(j));
            }
            aa = a.toString();
            bb = b.toString();
            if(map.containsKey(new Pair(aa,bb)))map.put(new Pair(aa,bb),map.get(new Pair(aa,bb)) + 1);
            else map.put(new Pair(aa,bb),1);
        }
        for(int i = 0;i < 1 << n;i ++) {
            StringBuilder a = new StringBuilder();
            StringBuilder b = new StringBuilder();
            for(int j = 0;j < n;j ++) {
                if((i >> j) % 2 == 1)a.append(s.charAt(n * 2 - 1 - j));
                else b.append(s.charAt(n * 2 - 1 - j));
            }
            aa = a.toString();
            bb = b.toString();
            if(map.containsKey(new Pair(aa,bb)))ans += map.get(new Pair(aa,bb));
        }
        System.out.println(ans);
    }
}