2014 ACM/ICPC Asia Regional Shanghai Online【未完成】

1012

the Sum of Cube

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2407    Accepted Submission(s): 936

Problem Description

A range is given, the begin and the end are both integers. You should sum the cube of all the integers in the range.

Input

The first line of the input is T(1 <= T <= 1000), which stands for the number of test cases you need to solve.
Each case of input is a pair of integer A,B(0 < A <= B <= 10000),representing the range[A,B].

Output

For each test case, print a line “Case #t: ”(without quotes, t means the index of the test case) at the beginning. Then output the answer – sum the cube of all the integers in the range.

Sample Input

2 1 3 2 5

Sample Output

Case #1: 36 Case #2: 224

 这个大水题居然wa一次

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 105;

int main() {
    int t;
    scanf("%d",&t);
    for(int kase = 1; kase <= t; kase++) {
        int a, b;
        scanf("%d %d",&a, &b);
        long long sum = 0;
        for(int i = a; i <= b; i++) {
            sum += i * i * i;
        }
        printf("Case #%d: %I64d
", kase, sum);
    }
    return 0;
}

wa的原因是对强制类型转换的不熟悉， 对于第16行i*i*i仍然是个int型但是不能自动转换为long long

所以只要加一个强转就可以了-。-

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 1005;

int main() {
    int t;
    int a, b;
    scanf("%d",&t);
    for(int kase = 1; kase <= t; kase++) {
        scanf("%d %d",&a, &b);
        long long sum = 0;
        for(int i = a; i <= b; i++) {
            sum += (long long ) i * i * i;
        }
        printf("Case #%d: %I64d
", kase, sum);
    }
    return 0;
}

1009

Divided Land

Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 1950    Accepted Submission(s): 659

Problem Description

It’s time to fight the local despots and redistribute the land. There is a rectangular piece of land granted from the government, whose length and width are both in binary form. As the mayor, you must segment the land into multiple squares of equal size for the villagers. What are required is there must be no any waste and each single segmented square land has as large area as possible. The width of the segmented square land is also binary.

Input

The first line of the input is T (1 ≤ T ≤ 100), which stands for the number of test cases you need to solve
Each case contains two binary number represents the length L and the width W of given land. (0 < L, W ≤ 2¹⁰⁰⁰)

Output

For each test case, print a line “Case #t: ”(without quotes, t means the index of the test case) at the beginning. Then one number means the largest width of land that can be divided from input data. And it will be show in binary. Do not have any useless number or space.

Sample Input

3 10 100 100 110 10010 1100

Sample Output

Case #1: 10 Case #2: 10 Case #3: 110

 大意：二进制求其gcd并且用二进制表示出来

2¹⁰⁰⁰

有点大直接用java大数

这里有一些java大数的常用函数：

  在用C或者C++处理大数时感觉非常麻烦，但是在JAVA中有两个类BigInteger和BigDecimal分别表示大整数类和大浮点数类，至于两个类的对象能表示最大范围不清楚，理论上能够表示无线大的数，只要计算机内存足够大。
这两个类都在java.math.*包中，因此每次必须在开头处引用该包。

Ⅰ基本函数：
1.valueOf(parament); 将参数转换为制定的类型
  比如 int a=3;
  BigInteger b=BigInteger.valueOf(a);
  则b=3;
  String s=”12345”;
  BigInteger c=BigInteger.valueOf(s);
  则c=12345；

2.add(); 大整数相加
BigInteger a=new BigInteger(“23”);
BigInteger b=new BigInteger(“34”);
a.      add(b);

3.subtract(); 相减
4.multiply(); 相乘
5.divide();    相除取整
6.remainder(); 取余
7.pow();   a.pow(b)=a^b
8.gcd();   最大公约数
9.abs(); 绝对值
10.negate(); 取反数
11.mod(); a.mod(b)=a%b=a.remainder(b);
12.max(); min();
13.punlic int comareTo();
14.boolean equals(); 是否相等
15.BigInteger构造函数：
一般用到以下两种：
BigInteger(String val);
将指定字符串转换为十进制表示形式；
BigInteger(String val,int radix);
将指定基数的 BigInteger 的字符串表示形式转换为 BigInteger
Ⅱ.基本常量：
A=BigInteger.ONE    1
B=BigInteger.TEN    10
C=BigInteger.ZERO   0
Ⅲ.基本操作
1.   读入：
用Scanner类定义对象进行控制台读入,Scanner类在java.util.*包中
Scanner cin=new Scanner(System.in);// 读入
while(cin.hasNext())   //等同于!=EOF
{
 int n;
 BigInteger m;
 n=cin.nextInt(); //读入一个int;
 m=cin.BigInteger();//读入一个BigInteger;
 System.out.print(m.toString());
}
Ⅳ.运用
四则预算：
import java.util.Scanner;
import java.math.*;
import java.text.*;
public class Main
{
 public static void main(String args[])
 {
  Scanner cin = new Scanner ( System.in );
  BigInteger a,b;
  int c;
  char op;
  String s;
  while( cin.hasNext() )
  {
   a = cin.nextBigInteger();
   s = cin.next();
   op = s.charAt(0);
   if( op == '+')
   {
    b = cin.nextBigInteger();
    System.out.println(a.add(b));
   }
   else if( op == '-')
   {
    b = cin.nextBigInteger();
    System.out.println(a.subtract(b));
   }
   else if( op == '*')
   {
    b = cin.nextBigInteger();
    System.out.println(a.multiply(b));
   }
   else
   {
    BigDecimal a1,b1,eps;
    String s1,s2,temp;
    s1 = a.toString();
    a1 = new BigDecimal(s1);
    b = cin.nextBigInteger();
    s2 = b.toString();
    b1 = new BigDecimal(s2);
    c = cin.nextInt();
    eps = a1.divide(b1,c,4);
    //System.out.println(a + " " + b + " " + c);
    //System.out.println(a1.doubleValue() + " " + b1.doubleValue() + " " + c);
    System.out.print( a.divide(b) + " " + a.mod(b) + " ");
    if( c != 0)
    {
     temp = "0.";
     for(int i = 0; i < c; i ++) temp += "0";
     DecimalFormat gd = new DecimalFormat(temp);
     System.out.println(gd.format(eps));
    }
    else System.out.println(eps);
   }
  }
 }
}
//=====================================================================================
//PKU1311八进制浮点数化为十进制浮点数，高精度
import java.io.*;
import java.util.*;
import java.math.*;
public class Main
{
 public static void main(String[] args)
 {
  Scanner cin=new Scanner(System.in);
  BigDecimal temp,sum,ans,num;  //java大数
  String str;
  int i,len;
  while(cin.hasNext())
  {
   str=cin.next();
   len=str.length();
   temp=BigDecimal.valueOf(8.0);
   sum=BigDecimal.ONE;
   ans=BigDecimal.ZERO;
   for(i=2;i<len;i++)
   {
    int val=str.charAt(i)-'0';
    num=BigDecimal.valueOf(val);
    sum=sum.multiply(temp);       //8的n次幂
    ans=ans.add(num.divide(sum)); //按权累加
   }
   System.out.printf("%s [8] = ",str);
   System.out.println(ans+" [10]");
  }
 }
}

代码：

import java.io.*;
import java.util.*;
import java.math.*;

public class b {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);

        int t = cin.nextInt();

        for(int kase = 1; kase <= t; kase++) {
            String s1, s2;

            BigInteger On = BigInteger.ONE;
            BigInteger Ze = BigInteger.ZERO;
            BigInteger Tw = BigInteger.valueOf(2);

            BigInteger sum1 = Ze; 
            BigInteger sum2 = Ze; 
            BigInteger t1 = On; 
            BigInteger t2 = On; 

            s1 = cin.next(); s2 = cin.next();
            int l1 = s1.length(); int l2 = s2.length();
            for(int i = l1 - 1; i >= 0; i--) {
                if(s1.charAt(i) == '1') {
                    sum1 = sum1.add(t1);
                }
                t1 = t1.multiply(Tw);
            }
            for(int i = l2 - 1; i >= 0; i--) {
                if(s2.charAt(i) == '1') {
                    sum2 = sum2.add(t2);
                }
                t2 = t2.multiply(Tw);
            }
            sum1 = sum1.gcd(sum2);
            int [] ans = new int [1005];
            int cnt = 0;
            while(!sum1.equals(Ze)) {
                if(sum1.mod(Tw).equals(On)) {
                    ans[cnt++] = 1;
                } else ans[cnt++] = 0;
                sum1 = sum1.divide(Tw);
            }
            System.out.print("Case #" + kase + ": ");
            for(int i = cnt - 1; i >= 0; i--) {
                System.out.print(ans[i]);
            }
            System.out.println("");
        }
    }
}

1004

Contest

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 1705    Accepted Submission(s): 446

Problem Description

In the ACM International Collegiate Programming Contest, each team consist of three students. And the teams are given 5 hours to solve between 8 and 12 programming problems.
On Mars, there is programming contest, too. Each team consist of N students. The teams are given M hours to solve M programming problems. Each team can use only one computer, but they can’t cooperate to solve a problem. At the beginning of the ith hour, they will get the ith programming problem. They must choose a student to solve this problem and others go out to have a rest. The chosen student will spend an hour time to program this problem. At the end of this hour, he must submit his program. This program is then run on test data and can’t modify any more.
Now, you have to help a team to find a strategy to maximize the expected number of correctly solved problems.
For each problem, each student has a certain probability that correct solve. If the i^th student solve the j^th problem, the probability of correct solve is P_ij .
At any time, the different between any two students’ programming time is not more than 1 hour. For example, if there are 3 students and there are 5 problems. The strategy {1,2,3,1,2}, {1,3,2,2,3} or {2,1,3,3,1} are all legal. But {1,1,3,2,3},{3,1,3,1,2} and {1,2,3,1,1} are all illegal.
You should find a strategy to maximize the expected number of correctly solved problems, if you have know all probability

Input

The first line of the input is T (1 ≤ T ≤ 20), which stands for the number of test cases you need to solve.
The first line of each case contains two integers N ,M (1 ≤ N ≤ 10,1 ≤ M ≤ 1000),denoting the number of students and programming problem, respectively
The next N lines, each lines contains M real numbers between 0 and 1 , the j^th number in the i^th line is P_ij .

Output

For each test case, print a line “Case #t: ”(without quotes, t means the index of the test case) at the beginning. Then a single real number means the maximal expected number of correctly solved problems if this team follow the best strategy, to five digits after the decimal point. Look at the output for sample input for details.

Sample Input

1 2 3 0.6 0.3 0.4 0.3 0.7 0.9

Sample Output

Case #1: 2.20000

分析：数位dp

 代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 1005;

double dp[1005][1<<11];
double p[15][1<<11];

int main() {
    int t;
    int n, m;
    scanf("%d", &t);
    for(int kase = 1; kase <= t; kase ++) {
        scanf("%d %d", &n, &m);
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                scanf("%lf", &p[i][j]);
            }
        }
        int maxa = 1 << n;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < maxa; j++) {
                dp[i][j] = -1.0;
            }
        }
        for(int i = 0; i < n; i++) {
            dp[0][1 << i] = p[i][0];
        }
        for(int i = 1; i < m; i++) {
            for(int j = 0; j < maxa; j++) {
                if(dp[i - 1][j] != -1) {
                    for(int k = 0; k < n; k++) {
                        if((j & ( 1 << k ) ) == 0 ) {
                            dp[i][j | ( 1 << k ) ] = max ( dp[i][j | ( 1 << k )], dp[i - 1][j] + p[k][i]);
                        }
                    }
                }
            }
            if(dp[i][maxa - 1] != -1) {
                dp[i][0] = dp[i][maxa - 1];
            }
            dp[i][maxa - 1] = -1;
        }
        double ans = 0;
        for(int i = 0; i < maxa; i++) {
            ans = max(ans, dp[m - 1][i]);
        }
        printf("Case #%d: %.5lf
", kase, ans);
    }
    return 0;
}

Sawtooth

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 2979    Accepted Submission(s): 450

Problem Description

Think about a plane:
● One straight line can divide a plane into two regions.
● Two lines can divide a plane into at most four regions.
● Three lines can divide a plane into at most seven regions.
● And so on...
Now we have some figure constructed with two parallel rays in the same direction, joined by two straight segments. It looks like a character “M”. You are given N such “M”s. What is the maximum number of regions that these “M”s can divide a plane ?

 

Input

The first line of the input is T (1 ≤ T ≤ 100000), which stands for the number of test cases you need to solve
Each case contains one single non-negative integer, indicating number of “M”s. (0 ≤ N ≤ 10¹²)

Output

For each test case, print a line “Case #t: ”(without quotes, t means the index of the test case) at the beginning. Then an integer that is the maximum number of regions N the “M” figures can divide.

Sample Input

2 1 2

Sample Output

Case #1: 2

Case #2: 19

 

题意：如图所示一个‘M’最多把一个平面分成两个部分，两个平面是19个

问给你n个平面最多能的分成多少个n的数量级是10^12

 

分析：

这个题的思路跟这个题是一样的

http://acm.hdu.edu.cn/showproblem.php?pid=2050

我们先考虑这么一道题：n条直线最多能够把一个平面分成几个平面

 

 我们知道对于第n条直线最多与n-1条直线相交，也就是最多有n-1个焦点

我们还知道对于每增加x一个焦点那么增加的平面个数x+1

也就是说对于第n条直线增了n个平面

a1 = 2；a2 = 2 + 2 = 4；

an = a1 + sum(2……n) = 2 + （(1+n) * n / 2 - 1） = n*(n+1)/2 + 1;

 

那么对于n对2条平行的直线呢

同样的

对于第n（n代表第n对）对直线 增加的焦点个数 为 2 * ( 2 * ( n - 1 ) )

同理可以获得增加的平面个数  对于单条直线每增加x个焦点增加x+1个平面

那么对于平行的两条直线每增加 增加的焦点个数为 2 * ( 2 * ( n - 1) + 1 ) 个平面  我们将它设为x

那么an  = a1 + sum（xi）【i = 2……n】

 

现在我们在考虑这么一个问题

如果不是平行的两条直线，而是v字形的呢像这样

我们发现对于一对平行线每增加一个焦点平面个数就减一

那么n对平行线就是总平面个数减去n即可

 

到这里思路已经全部说完了

“M"就是四条平行线s个焦点

只要求出平行线的平面数再减去3n就可以了

 

最终的的公式为   an = 8*n*n - 7 * n + 1

但是作者卡java的大数……*&……（*&%*&%&……&%*&（*）&（**&%&%&……%￥……*&……*%……&￥%……￥……%#￥#%……￥

其实很好考虑的longlong的最大值9223372036854775807 也就说9*10^17只内就能承受

于是我们这么考虑

对于两个数相乘

形式如ab*cd

那么

       a  b

*     c  d

--------------

=      ad  bd

    ac  bc

----------------

= ac（ad+bc）bd

 

所以我们可以把10^12分成两个部分分别计算每个部分10^7

最后合并起来不够的用零填充%07I64d  %07lld

 

代码：

 

#include <iostream>
#include <cstdio>
#include <cstdio>
using namespace std;

typedef long long LL;
const int mod = 10000000;

int main() {
    LL a, b, a1, a2, b1, b2, n, ans1, ans2, ans3;
    int t;
    scanf("%d",&t);
    for(int kase = 1; kase <= t; kase++) {
        scanf("%I64d", &n);
        a = n; b = n * 8 - 7;
        a1 = a / mod; a2 = a % mod;
        b1 = b / mod; b2 = b % mod;
        ans1 = 0; ans2 = 0; ans3 = 0;
        ans3 = a2 * b2 + 1; ans2 = a1 * b2 + a2 * b1; ans1 = a1 * b1;
        ans2 += ans3 / mod; ans3 %= mod;
        ans1 += ans2 / mod; ans2 %= mod;
        printf("Case #%d: ", kase);
        if(ans1) {
            printf("%I64d%07I64d%07I64d
", ans1, ans2, ans3);
        } else if(ans2) {
            printf("%I64d%07I64d
", ans2, ans3);
        } else {
            printf("%I64d
",ans3);
        }

    }
    return 0;
}