poj3007--Organize Your Train part II(hash)

Organize Your Train part II

Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 7365   Accepted: 2130

Description

RJ Freight, a Japanese railroad company for freight operations has recently constructed exchange lines at Hazawa, Yokohama. The layout of the lines is shown in Figure 1.

Figure 1: Layout of the exchange lines

A freight train consists of 2 to 72 freight cars. There are 26 types of freight cars, which are denoted by 26 lowercase letters from "a" to "z". The cars of the same type are indistinguishable from each other, and each car‘s direction doesn‘t matter either.
Thus, a string of lowercase letters of length 2 to 72 is sufficient to completely express the configuration of a train.

Upon arrival at the exchange lines, a train is divided into two sub-trains at an arbitrary position (prior to entering the storage lines). Each of the sub-trains may have its direction reversed (using the reversal line). Finally, the two sub-trains are connected
in either order to form the final configuration. Note that the reversal operation is optional for each of the sub-trains.

For example, if the arrival configuration is "abcd", the train is split into two sub-trains of either 3:1, 2:2 or 1:3 cars. For each of the splitting, possible final configurations are as follows ("+" indicates final concatenation position):

  [3:1]
    abc+d  cba+d  d+abc  d+cba
  [2:2]
    ab+cd  ab+dc  ba+cd  ba+dc  cd+ab  cd+ba  dc+ab  dc+ba
  [1:3]
    a+bcd  a+dcb  bcd+a  dcb+a

Excluding duplicates, 12 distinct configurations are possible.

Given an arrival configuration, answer the number of distinct configurations which can be constructed using the exchange lines described above.

Input

The entire input looks like the following.

the number of datasets = m

1st dataset

2nd dataset

...

m-th dataset

Each dataset represents an arriving train, and is a string of 2 to 72 lowercase letters in an input line.

Output

For each dataset, output the number of possible train configurations in a line. No other characters should appear in the output.

Sample Input

4
aa
abba
abcd
abcde

Sample Output

1
6
12
18

Source

Japan 2006 Domestic

题意:将一个字符串可以任意分成两节,任意颠倒顺序,问最终会得到几个字符串。

hash储存下字符串,字符串长度为72,每一次分开后,最多有8种情况,所以最多不会超过72*8种。

遍历分开的节点的位置,hash查找

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <string>
using namespace std ;
struct node{
    char s[100] ;
    int next ;
}p[100000];
int head[400000] , cnt ;
char str[100] , s[100] , s1[100] , s2[100] ;
int num ;
void hash1(int k)
{
    int i , j ;
    for(i = head[k] ; i != -1 ; i = p[i].next)
    {
        if( strcmp(p[i].s,s) == 0 )
            break ;
    }
    if( i == -1 )
    {
        num++ ;
        strcpy(p[cnt].s,s) ;
        p[cnt].next = head[k] ;
        head[k] = cnt++;
    }
    return ;
}
void solve(char *s1,char *s2)
{
    int j , k , l1 = strlen(s1) , l2 = strlen(s2) ;
    for(j = 0 , k = 0 ; j < l1+l2 ; j++)
    {
        if( j < l1 )
            s[j] = s1[j] ;
        else
            s[j] = s2[j-l1] ;
        k += s[j]*j ;
    }
    s[l1+l2] = '\0' ;
    hash1(k) ;

    for(j = 0 , k = 0 ; j < l1+l2 ; j++)
    {
        if( j < l1 )
            s[j] = s1[j] ;
        else
            s[j] = s2[l2-1-(j-l1)] ;
        k += s[j]*j ;
    }
    s[l1+l2] = '\0' ;
    hash1(k) ;

    for(j = 0 , k = 0 ; j < l1+l2 ; j++)
    {
        if( j < l1 )
            s[j] = s1[l1-1-j] ;
        else
            s[j] = s2[j-l1] ;
        k += s[j]*j ;
    }
    s[l1+l2] = '\0' ;
    hash1(k) ;

    for(j = 0 , k = 0 ; j < l1+l2 ; j++)
    {
        if( j < l1 )
            s[j] = s1[l1-1-j] ;
        else
            s[j] = s2[l2-1-(j-l1)] ;
        k += s[j]*j ;
    }
    s[l1+l2] = '\0' ;
    hash1(k) ;

    return ;
}
int main()
{
    int m , i , j , l ;
    scanf("%d", &m) ;
    while( m-- )
    {
        memset(head,-1,sizeof(head)) ;
        cnt = 0 ;
        num = 0 ;
        scanf("%s", str) ;
        l = strlen(str) ;
        for(i = 0 ; i < l-1 ; i++)
        {
            for(j = 0 ; j <= i ; j++)
                s1[j] = str[j] ;
            s1[j] = '\0' ;
            for(j = i+1 ; j < l ; j++)
                s2[j-i-1] = str[j] ;
            s2[j-i-1] = '\0' ;
            solve(s1,s2) ;
            solve(s2,s1) ;
        }
        printf("%d\n", num) ;
    }
    return 0 ;
}

时间: 2024-11-09 03:42:35

poj3007--Organize Your Train part II(hash)的相关文章

POJ3007(Organize Your Train part II)

传送门 Organize Your Train part II Time Limit: 1000MS   Memory Limit: 65536K       Description RJ Freight, a Japanese railroad company for freight operations has recently constructed exchange lines at Hazawa, Yokohama. The layout of the lines is shown i

poj3007 Organize Your Train part II, 字符串hash

题意: 给定一个字符串,从任意位置把它切为两半,得到两条子串 定义 子串1为s1,子串2为s2,子串1的反串为s3,子串2的反串为s4 现在从s1 s2 s3 s4中任意取出两个串组合,问有多少种不同的组合方法 #include <cmath> #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #include <set> #in

POJ 3007 Organize Your Train part II

题意: 如上图所示,将一个字符串进行分割,反转等操作后不同字符串的个数: 例如字符串abba:可以按三种比例分割:1:3:2:2:3:1 部分反转可以得到如下所有的字符串: 去掉重复可以得到六个不同的字符串,输出6: 解题思路: 此题用反转函数reverse比较方便,然后就和模拟差不多,要列出所有情况,把不同的字符串保存在一个字符数组中,每次得到一个字符串都和该字符数字中的每一个比较,如果都不相同,把它存入字符数组:. 直接看代码吧: 1 //Organize Your Train part I

Train Problem II 卡特兰裸题(入门题)

Train Problem II  题目大意:给你一个数n,表示有n辆火车,编号从1到n,从远方驶过来,问你有多少种出站的可能. 解题思路:模拟栈的问题而已.  卡特兰问题. 1 import java.math.*; 2 import java.util.*; 3 import java.io.*; 4 5 public class Main 6 { 7 static int MS=101; 8 public static void main(String[] args) 9 { 10 Sca

hdoj 1023 Train Problem II 【卡特兰】+【高精度】

题意:询问有多少种进站出站的顺序. 经典卡特兰.我对卡特兰目前的认识就是有n个1和n个-1,组成一个为2n的数列的方式有多少种.这就跟火车进站出站类似, 至于具体的卡特兰数的介绍,百度解释的很详细. 代码1(c语言): /* h(n) = h(n-1)*(4*n-2)/(n+1); */ #include <stdio.h> #include <string.h> #define M 110 int s[M][M] = {0}, b[M]; void init(){ s[1][0]

HDU——1023 Train Problem II

Train Problem II Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 9701    Accepted Submission(s): 5210 Problem Description As we all know the Train Problem I, the boss of the Ignatius Train Stat

C - Train Problem II——(HDU 1023 Catalan 数)

传送门 Train Problem II Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 7616    Accepted Submission(s): 4101 Problem Description As we all know the Train Problem I, the boss of the Ignatius Train

ACM-卡特兰数之Train Problem II——hdu1023

***************************************转载请注明出处:http://blog.csdn.net/lttree*************************************** Train Problem II Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 5589    Accept

hdu 1023 Train Problem II 这题运用到大数相乘+大数相除+卡特兰数

Train Problem II Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6454    Accepted Submission(s): 3514 Problem Description As we all know the Train Problem I, the boss of the Ignatius Train Stat