2014 ACM-ICPC Beijing Invitational Programming Contest

点击打开链接

Happy Reversal

Time Limit: 1000ms

Memory Limit: 65536KB

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!

Elfness is studying in an operation " NOT".

For a binary number A, if we do operation " NOT A", after that, all digits of A will be reversed. (e.g. A= 1001101, after operation " NOT A", A will be  0110010).

Now Elfness has N binary numbers of length K, now he can do operations " NOT" for some of his numbers. 

Let's assume after his operations, the maximum number is M, the minimum number is P. He wants to know what's the maximum M - P he can get. Can you help him?

 

Input

The first line of input is an integer T (T ≤ 60), indicating the number of cases.

For each case, the first line contains 2 integers N (1 ≤ N ≤ 10000) and K (1 ≤ K ≤ 60), the next N lines contains N binary numbers, one number per line, indicating the numbers that Elfness has. The length of each binary number is K.

 

Output

For each case, first output the case number as "Case #x: ", and x is the case number. Then you should output an integer, indicating the maximum result that Elfness can get.

Sample Input

2
5 6
100100
001100
010001
010001
111111
5 7
0001101
0001011
0010011
0111000
1001011

Sample Output

Case #1: 51
Case #2: 103

Source

2014 ACM-ICPC Beijing Invitational Programming Contest

给你n组由k个0或者1组成的二进制数。每个数可以翻转，求两个数的最大差值。

//152 ms 1788 KB
#include<stdio.h>
#include<algorithm>
using namespace std;
char s[107];
long long ans[20007];
int n,m;
long long getnum()
{
    long long res=0,j=1;
    for(int i=m-1;i>=0;i--,j*=2)
        if(s[i]=='1')res+=j;
    return res;
}
int main()
{
    int t,cas=1;
    scanf("%d",&t);
    while(t--)
    {
        int k=0;
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++)
        {
            scanf("%s",s);
            ans[k++]=getnum();
            for(int j=0;j<m;j++)
                if(s[j]=='1')s[j]='0';
                else s[j]='1';
            ans[k++]=getnum();
        }
        sort(ans,ans+k);
        long long ans1=ans[k-1]-ans[1];
        long long ans2=ans[k-2]-ans[0];
        long long p=ans[0],q=ans[k-1];
        long long e=1<<(m-1);
        if((p^q)&e==e)
            printf("Case #%d: %lld\n",cas++,max(ans1,ans2));
        else printf("Case #%d: %lld\n",q-p);
    }
    return 0;
}