UVA 12545 Bits Equalizer

最新推荐文章于 2018-09-22 22:39:39 发布

weixin_30719711

最新推荐文章于 2018-09-22 22:39:39 发布

阅读量135

点赞数

CC 4.0 BY-SA版权

文章标签： java php

原文链接：http://www.cnblogs.com/qq-star/p/4674056.html

本文介绍了一道编程题的解题思路与实现方法，题目要求将包含“0”、“1”和“?”的字符串S通过有限操作转换成仅由“0”和“1”组成的字符串T，探讨了字符替换与交换的最小步骤。

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

题目链接：http://www.bnuoj.com/bnuoj/problem_show.php?pid=27865

Bits Equalizer

Time Limit: 1000ms

Memory Limit: 131072KB

This problem will be judged on UVA. Original ID: 12545
64-bit integer IO format: %lld Java class name: Main

Prev Submit Status Statistics Discuss Next

Font Size: + -

Type: None Graph Theory 2-SAT Articulation/Bridge/Biconnected Component Cycles/Topological Sorting/Strongly Connected Component Shortest Path Bellman Ford Dijkstra/Floyd Warshall Euler Trail/Circuit Heavy-Light Decomposition Minimum Spanning Tree Stable Marriage Problem Trees Directed Minimum Spanning Tree Flow/Matching Graph Matching Bipartite Matching Hopcroft–Karp Bipartite Matching Weighted Bipartite Matching/Hungarian Algorithm Flow Max Flow/Min Cut Min Cost Max Flow DFS-like Backtracking with Pruning/Branch and Bound Basic Recursion IDA* Search Parsing/Grammar Breadth First Search/Depth First Search Advanced Search Techniques Binary Search/Bisection Ternary Search Geometry Basic Geometry Computational Geometry Convex Hull Pick's Theorem Game Theory Green Hackenbush/Colon Principle/Fusion Principle Nim Sprague-Grundy Number Matrix Gaussian Elimination Matrix Exponentiation Data Structures Basic Data Structures Binary Indexed Tree Binary Search Tree Hashing Orthogonal Range Search Range Minimum Query/Lowest Common Ancestor Segment Tree/Interval Tree Trie Tree Sorting Disjoint Set String Aho Corasick Knuth-Morris-Pratt Suffix Array/Suffix Tree Math Basic Math Big Integer Arithmetic Number Theory Chinese Remainder Theorem Extended Euclid Inclusion/Exclusion Modular Arithmetic Combinatorics Group Theory/Burnside's lemma Counting Probability/Expected Value Others Tricky Hardest Unusual Brute Force Implementation Constructive Algorithms Two Pointer Bitmask Beginner Discrete Logarithm/Shank's Baby-step Giant-step Algorithm Greedy Divide and Conquer Dynamic Programming Tag it!

[PDF Link]

You are given two non-empty strings S and T of equal lengths. S contains the characters `0', `1' and `?', whereas T contains `0' and `1' only. Your task is to convertS into T in minimum number of moves. In each move, you can

change a `0' in S to `1'
change a `?' in S to `0' or `1'
swap any two characters in S

As an example, suppose S = "01??00" and T = "001010". We can transform S into T in 3 moves:

Initially S = "01??00"
- Move 1: change S[2] to `1'. S becomes "011?00"
- Move 2: change S[3] to `0'. S becomes "011000"
- Move 3: swap S[1] with S[4]. S becomes "001010"
S is now equal to T

Input

The first line of input is an integer C (C $\le$ 200) that indicates the number of test cases. Each case consists of two lines. The first line is the string S consisting of `0', `1' and `?'. The second line is the string T consisting of `0' and `1'. The lengths of the strings won't be larger than 100.

Output

For each case, output the case number first followed by the minimum number of moves required to convert S into T. If the transition is impossible,output `-1' instead.

Sample Input

Sample Output

Case 1: 3
Case 2: 1
Case 3: -1

Source

Western and Southwestern European Regionals, 2012 - Valencia

题目大意：将第一个字符与第二个字符每一个位置都相对应，至少需要移动的次数为多少。有以下的规则：1、0可以变成1；2、？可以变成0 or 1；3、任意0与1的位置可以互换

解题思路：统一0和1以及？的个数，因为？一定要变换，所以最少移动次数也得有？个数次，所以在其基础上加就可以了。

分两种情况考虑：（交换、变换）

优先变换情况：

1、存在1/0，并且后面可以找到0/1，那么交换。

2、存在1/0，但是找不到与其对应的0/1可以交换，那么就只能选择？/1,那么交换。

变换情况：

1、存在0/1，这种情况的话就直接把0变换成1即可。

综上，只要把所有情况考虑到，AC就不再是梦想啦，哇哈哈~~

详见代码。

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 
 5 using namespace std;
 6 
 7 int main ()
 8 {
 9     int n,len1,flag=1;
10     char s[110],t[110];
11     scanf("%d",&n);
12     while (n--)
13     {
14         scanf("%s%s",s,t);
15         len1=strlen(s);
16         //len2=strlen(t);
17         int a,b,c,aa,bb;
18         a=b=c=aa=bb=0;
19         for (int i=0; i<len1; i++)
20         {
21             if (s[i]=='0')
22                 a++;
23             else if (s[i]=='1')
24                 b++;
25             else
26                 c++;
27         }
28         for (int i=0; i<len1; i++)
29         {
30             if (t[i]=='0')
31                 aa++;
32             else
33                 bb++;
34         }
35         if (b>bb)
36         {
37             printf ("Case %d: -1\n",flag++);
38             continue;
39         }
40         int sum=0;
41         int j;
42         if (s[i]=='1'&&t[i]=='0')
43         {
44             for (j=0; j<len1; j++)
45             {
46                 if (s[j]=='0'&&t[j]=='1')
47                 {
48                     sum++;
49                     s[i]='0';
50                     s[j]='1';
51                     break;
52                 }
53             }
54             if (j>=len1)
55                 break;
56 
57         }
58     }
59     for (int i=0; i<len1; i++)
60     {
61         int j;
62         if (s[i]=='1'&&t[i]=='0')
63         {
64             for (j=0; j<len1; j++)
65             {
66                 if (s[j]=='?'&&t[j]=='1')
67                 {
68                     sum++;
69                     s[i]='?';
70                     s[j]='1';
71                     break;
72                 }
73             }
74             if (j>=len1)
75                 break;
76         }
77     }
78     for (int i=0; i<len1; i++)
79     {
80         if (s[i]=='0'&&t[i]=='1')
81             sum++;
82         //ans=sum+c;
83     }
84     printf ("Case %d: %d\n",flag++,sum+c);
85 }
86 return 0;
87 }