Fewest Flops

最新推荐文章于 2018-04-28 20:56:05 发布

Lakersman

最新推荐文章于 2018-04-28 20:56:05 发布

阅读量361

点赞数

分类专栏：算法 - 动态规划

本文链接：https://blog.csdn.net/lakersman/article/details/47212581

版权

算法 - 动态规划专栏收录该内容

14 篇文章 0 订阅

订阅专栏

A common way to uniquely encode a string is by replacing its consecutive repeating characters (or “chunks”) by the number of times the character occurs followed by the character itself. For example, the string “aabbbaabaaaa” may be encoded as “2a3b2a1b4a”. (Note for this problem even a single character “b” is replaced by “1b”.)

Suppose we have a string S and a number k such that k divides the length of S. Let S1 be the substring of S from 1 to k, S2 be the substring of S from k + 1 to 2k, and so on. We wish to rearrange the characters of each block Si independently so that the concatenation of those permutations S’ has as few chunks of the same character as possible. Output the fewest number of chunks.

For example, let S be “uuvuwwuv” and k be 4. Then S1 is “uuvu” and has three chunks, but may be rearranged to “uuuv” which has two chunks. Similarly, S2 may be rearranged to “vuww”. Then S’, or S1S2, is “uuuvvuww” which is 4 chunks, indeed the minimum number of chunks.

Program Input

The input begins with a line containing t (1 ≤ t ≤ 100), the number of test cases. The following t lines contain an integer k and a string S made of no more than 1000 lowercase English alphabet letters. It is guaranteed that k will divide the length of S.

Program Output

For each test case, output a single line containing the minimum number of chunks after we rearrange S as described above.

INPUT

2
5 helloworld
7 thefewestflops

OUTPUT

8
10

这是我自己写的，我并没有用动态规划，而是用了分类讨论，由于从左到右的过程中，每两个相邻块只有三种情况：

①没有相同字符；

②有一个相同字符；

③有两个以上相同字符；

第一种情况是很简单，第二中情况也同样简单，只不过要标记该字符，第三种情况的话不用标记，也很简单。

在标记了之后其实要进行更多情况的分类。

由于分类讨论不够严谨，WA了很多次。

int dp(int m)

{
int ans = flag[0][0];

for(int i = 1; i < m; i++)
{
int cnt1 = 0, cnt2 = 0;
int which1 = -1, which2 = -1;

for(int j = 1; j < 27; j++)
{
if(flag[i][j] == 1)
{
if(flag[i-1][j] == 1)
{
cnt1++;
which1 = j;
}
else if(flag[i-1][j] == -1)
{
cnt2++;
which2 = j;
}
}
}

if(cnt1 == 0)
{
if(cnt2 == 1 && flag[i-1][0] == 1)
{
ans += flag[i][0] - 1;
flag[i][which2] = -1;
}
else ans += flag[i][0];
}
else if(cnt1 == 1)
{
if(cnt2 == 1 && flag[i-1][0] == 1)
{
ans += flag[i][0] - 1;
}
else
{
flag[i][which1] = -1;
ans += flag[i][0] - 1;
}
}
else //cnt >= 2
{
ans += flag[i][0] - 1;
}
}

return ans;

}

我还是在网上找了动态规划的方案：

int dp(int k, int m)
{
for(int x = 0; x < 1000; x++)
{
for(int y = 0; y < 27; y++) d[x][y] = INF;
}

for(int i = 1; i <= 26; i++)
{
if(data[0][i]) d[0][i] = data[0][0];
}

int chunck = data[0][0];

for(int t = 1; t < m; t++)
{
int best = INF;

for(int i = 1; i <= 26; i++) if(data[t][i]) //当前块以字符('a'+i)开头
{
for(int j = 1; j <= 26; j++) if(data[t][j] && (i != j || data[t][0] == 1))
//当前块以字符('a'+j-1)结尾，有限制，即开头不等于结尾除非该块只有一种字符
{
//如果前面的块有以当前块开头的字符结尾的排列...
if(d[t-1][i] < INF)
{
d[t][j] = min(d[t][j], d[t-1][i] + data[t][0] - 1);
}
else //否则...
{
d[t][j] = min(d[t][j], chunck + data[t][0]);
}
if(best > d[t][j]) best = d[t][j];
}
}

chunck = best;
}

int ans = d[m-1][1];
for(int j = 2; j <= 26; j++)
{
if(d[m-1][j] < ans)
{
ans = d[m-1][j];
}
}
return ans;
}