博客园_银河

C语言常用数据类型的大小

2012-01-31T13:49:00Z

在C语言中，常用的数据类型的大小是随操作系统和编译器等因素变化的。

 1 #include <stdio.h>
 2 #include <float.h>
 3 
 4 #define PR(x) printf("%11s: %2lu bytes\n", #x, (unsigned long)sizeof(x))
 5 
 6 int main(void)
 7 {
 8   PR(size_t);
 9   PR(void *);
10   PR(char);
11   PR(short);
12   PR(int);
13   PR(long);
14   PR(long long);
15   PR(float);
16   PR(double);
17   PR(long double);
18   printf("\n---- DIG -------EPSILON -----------MIN -----------MAX\n");
19   printf(" FLT %3d %-14E %-14E %-14E\n", FLT_DIG, FLT_EPSILON, FLT_MIN, FLT_MAX);
20   printf(" DBL %3d %-14E %-14E %-14E\n", DBL_DIG, DBL_EPSILON, DBL_MIN, DBL_MAX);
21   printf("LDBL %3d %-14LE %-14LE %-14LE\n", LDBL_DIG, LDBL_EPSILON, LDBL_MIN, LDBL_MAX);
22   printf("---- --- -------------- -------------- --------------\n");
23   return 0;
24 }

这个程序在 ideone.com 中的运行结果如下所示(http://ideone.com/jH1dT)：

size_t:  4 bytes
     void *:  4 bytes
       char:  1 bytes
      short:  2 bytes
        int:  4 bytes
       long:  4 bytes
  long long:  8 bytes
      float:  4 bytes
     double:  8 bytes
long double: 12 bytes

---- DIG -------EPSILON -----------MIN -----------MAX
 FLT   6 1.192093E-07   1.175494E-38   3.402823E+38  
 DBL  15 2.220446E-16   2.225074E-308  1.797693E+308 
LDBL  18 1.084202E-19   3.362103E-4932 1.189731E+4932
---- --- -------------- -------------- --------------

实际上，这是一个 32-bit 的 linux 操作系统，编译器是 gcc 4.3.4。

这个程序在 openSuSE 12.1 64-bit 操作系统中的运行结果如下所示(编译器是 gcc 4.6.2)：

size_t:  8 bytes
     void *:  8 bytes
       char:  1 bytes
      short:  2 bytes
        int:  4 bytes
       long:  8 bytes
  long long:  8 bytes
      float:  4 bytes
     double:  8 bytes
long double: 16 bytes

---- DIG -------EPSILON -----------MIN -----------MAX
 FLT   6 1.192093E-07   1.175494E-38   3.402823E+38
 DBL  15 2.220446E-16   2.225074E-308  1.797693E+308
LDBL  18 1.084202E-19   3.362103E-4932 1.189731E+4932
---- --- -------------- -------------- --------------

上述结果中，long double 是 16 bytes 的，但是实际上其范围和精度是和 12 bytes 的是一样的，可能是在 64-bit 操作系统中为了对齐字节边界的考虑吧。

本文链接

【算法】验证哥德巴赫猜想

2011-12-04T13:36:00Z

问题来源

Timus Online Judge 网站上有这么一道题目：1356. Something Easier。这道题目的输入是一组 2 到 10⁹ 之间整数，对于每个输入的整数，要求用最少个数的素数的和来表示。这道题目的时间限制是 1 秒。

问题解答

我们知道著名的哥德巴赫猜想是：

任何一个充分大的偶数都可以表示为两个素数之和

于是我们有以下的 C 语言程序(1356.c)：

// http://acm.timus.ru/problem.aspx?space=1&num=1356
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

// http://en.wikipedia.org/wiki/Prime_number_theorem
#define PRIME_MAX 10000
#define PRIME_COUNT 1229

typedef unsigned long long U8;
typedef char bool;

const bool true = 1;
const bool false = 0;

// http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
bool* getSieve(int max)
{
  static bool sieve[(PRIME_MAX >> 1) + 1];
  int i, j, imax = sqrt(max);
  for (i = 3; i <= imax; i += 2)
    if (!sieve[i >> 1])
      for (j = i * i; j <= max; j += i << 1) sieve[j >> 1] = true;
  return sieve;
}

int* getPrimes(int max)
{
  static int primes[PRIME_COUNT + 1];
  bool *sieve = getSieve(max);
  int i, j = 0;
  for (primes[j++] = 2, i = 3; i <= max; i += 2)
    if (!sieve[i >> 1]) primes[j++] = i;
  return primes;
}

U8 modMultiply(U8 a, U8 b, U8 m)
{
  return a * b % m;
}

U8 modPow(U8 a, U8 b, U8 m)
{
  U8 v = 1, p;
  for (p = a % m; b > 0; b >>= 1, p = modMultiply(p, p, m))
    if (b & 1) v = modMultiply(v, p, m);
  return v;
}

bool witness(U8 a, U8 n)
{
  U8 n1 = n - 1, s2 = n1 & -n1, x = modPow(a, n1 / s2, n);
  if (x == 1 || x == n1) return false;
  for (; s2 > 1; s2 >>= 1)
  {
    x = modMultiply(x, x, n);
    if (x == 1) return true;
    if (x == n1) return false;
  }
  return true;
}

U8 random(U8 high)
{
  // http://www.cppreference.com/wiki/c/other/rand
  return (U8)(high * (rand() / (double)RAND_MAX));
}

// http://en.wikipedia.org/wiki/Miller-Rabin_primality_test
// n, an integer to be tested for primality
// k, a parameter that determines the accuracy of the test
bool probablyPrime(U8 n, int k)
{
  if (n == 2 || n == 3) return 1;
  if (n < 2 || n % 2 == 0) return 0;
  while (k-- > 0) if (witness(random(n - 3) + 2, n)) return false;
  return true;
}

bool isPrime(int n)
{
  return probablyPrime(n, 2);
}

int outEven(int primes[], int n)
{
  int i, p, q;
  for (i = 0; (p = primes[i]) != 0; i++)
    if (isPrime(q = n - p))
      return printf("%d %d", p, q);
  return printf("error:%d", n);
}

int main(void)
{
  int t, n, *primes = getPrimes(PRIME_MAX);
  srand(time(NULL));
  scanf("%d", &t);
  while (t-- > 0)
  {
    scanf("%d", &n);
    if (isPrime(n)) printf("%d", n);
    else if ((n & 1) == 0) outEven(primes, n);
    else if (isPrime(n - 2)) printf("2 %d", n - 2);
    else printf("3 "), outEven(primes, n - 3);
    puts("");
  }
  return 0;
}

上述程序分析如下：

根据哥德巴赫猜想，充分大的偶数 n = p + q，这里 p <= q 是素数。我们猜测当 n <= 10⁹ 时，p < 10⁴。第 8 行就是定义 p 的最大值。
根据素数定理，我们知道 10⁴ 以内的素数有 1229 个。第 9 行就是定义程序中要用到的素数的个数。
第 17 到 26 行的 getSieve 函数用埃拉托斯特尼筛法筛选出素数。
第 28 到 36 行的 getPrimes 函数从筛中取出这些素数。
第 38 到 79 行的一系列函数最终是为了 probablyPrime 函数，用于检测素数。请参见我在2010年7月写的随笔：【算法】米勒-拉宾素性检验。
第 81 到 84 行的 isPrime 函数调用 probablyPrime 函数来检测素数。
第 86 到 93 行的 outEven 函数对大于 2 的偶数验证哥德巴赫猜想，即输出一对素数 p 和 q。
第 95 到 110 行是 main 函数。其中：
第 103 行处理 n 是素数的情况，直接输出该素数(包括素数 2，所以 outEven 函数处理的偶数肯定大于 2)。
第 104 行对大于 2 的偶数输出一对素数(通过调用 outEven 函数，强哥德巴赫猜想)。
第 105 行处理大于 5 的奇数能够分解为 2 和另外一个素数的和的情况(注意不要遗漏这个情形!)。
第 106 行处理大于 5 的奇数的其他情况，首先输出一个 3，然后调用 outEven 函数处理偶数 n - 3 (弱哥德巴赫猜想)。

上述程序在 Timus Online Judge 网站的运行时间是 0.015 秒。

参考资料

更多的 ACM 题的解法请参见：Timus 目录。

本文链接

【算法】将正整数表示为平方数之和

2011-11-26T15:28:00Z

问题来源

Timus Online Judge 网站上有这么一道题目：1073. Square Country。这道题目的输入是一个不大于 60,000 的正整数，要求计算出该正整数最少能够使用多少个正整数的平方和来表示。这道题目的时间限制是 1 秒。

问题解答

《数论导引(第5版)》([英]G.H.Hardy、E.M.Wright 著，人民邮电出版社，2008年10月第1版)第 320 页有以下定理：

定理 369(Lagrange 定理): 每个正整数都是四个平方数之和

在这个定理中，平方数是指整数(包括零)的平方。所以，我们有以下 C 语言程序(1073.c):

// http://acm.timus.ru/problem.aspx?space=1&num=1073
#include <stdio.h>
#include <math.h>

int compute(int n)
{
  int i, j, k, m = 4;
  int i0 = n / 4, i2 = n, j2, k2;
  for (i = sqrt(n); i2 > i0; i--)
    if ((j2 = n - (i2 = i * i)) == 0) return 1;
    else for (j = sqrt(j2); j > 0; j--)
      if ((k2 = n - i2 - j * j) == 0) return 2;
      else if (k = sqrt(k2), k * k == k2 && m > 3) m = 3;
  return m;
}

int main(void)
{
  int n;
  scanf("%d", &n);
  printf("%d", compute(n));
  return 0;
}

上述程序中：

第 7 行设置 m 的初值为 4，代表一个正整数最多只需要四个平方数就可以表示了。
第 9 行开始的主循环决定第一个平方数，如果 n 刚好是平方数(第 10 行)，就直接返回 1。
第 11 行开始的内循环决定第二个平方数，如果这两个数加起来刚好等于 n (第 12 行)，就直接返回 2。
第 13 行检查 n 是否可以表示为三个平方数的和，如果是的话，就更新 m 的值为 3 。注意，此时不能直接返回 3，因为可能在后面的循环中发现 n 可以用两个平方数表示。
第 14 行返回 m 值(只可能是 3 或者 4)作为最后的答案。

上述程序在 Timus Online Judge 网站的运行时间是 0.015 秒。

更好的算法

上述题目有一个进一步的版本：1593. Square Country. Version 2，输入改为不大于 10¹⁵ 的正整数，时间限制还是 1 秒。上一节的程序做以下改动：

第 5 行的第 2 个 int 改为 long long
第 8 和 19 行的 int 改为 long long
第 20 行的 %d 改为 %lld

就可以适用于这道题目，但是运行结果是“Time limit exceeded”。此时，需要更好的算法。我们有以下 C 语言程序(1593.c)：

// http://acm.timus.ru/problem.aspx?space=1&num=1593
#include <stdio.h>
#include <math.h>

int compute(long long n)
{
  int i, k;
  long long i2;
  while ((n & 3) == 0) n >>= 2;
  if ((n & 7) == 7) return 4;
  for (i = 8, i2 = 9; i2 <= n; i2 += i += 8)
    while (n % i2 == 0) n /= i2;
  if (n == 1) return 1;
  if ((n & 1) == 0) n >>= 1;
  if ((n & 3) == 3) return 3;
  for (k = sqrt(n), i = 3; i <= k && n % i; i += 4) ;
  return (i > k) ? 2 : 3;
}

int main(void)
{
  long long n;
  scanf("%lld", &n);
  printf("%d", compute(n));
  return 0;
}

在上述程序中：

第 9 行消去 n 的所有值为 4 因数。
第 10 行检测 n 是否为 8m + 7 的形式，如是，直接返回 4 (请参见下节)。
第 11、12 行消去 n 的所有素因子的偶次幂(素因子 2 的偶次幂已经在第 9 行消去了)。
第 11 行中 i2 依次为：3²、5²、7²、...、t²，这是因为 (t + 1)² - (t - 1)² = 4t，每次循环 t 增加 2，所以 i 增加 4 * 2 = 8。
第 13 行，如果 n 等于 1，说明输入是个完全平方数，直接返回 1。
此时，n 的标准分解式中所有的素因子都是一次幂了。
第 14 行消去 n 的素因子 2 (如果有的话)。
第 16 行的循环中 i 从 3 开始，每次递增 4，以检查 n 是否有 4m + 3 形式的因子。
第 15 行和第 17 行根据定理 366 决定答案是两个还是三个平方之和。

这个程序在 Timus Online Judge 网站的运行时间是 0.828 秒。这道题目的最佳运行时间是 0.031 秒，不知道使用什么算法可以这么快。

上述算法的原理

《数论导引(第5版)》第 329 页说：

n ≠ 4^a(8m + 7) 是 n 可以用三个平方数表示的一个充分必要条件

第 318 页有以下定理：

定理 366: 一个数 n 是两个平方之和，当且仅当在 n 的标准分解式中，它的所有形如 4m + 3 的素因子都有偶次幂

我们还有以下定理：

形如 4m + 3 的整数有形如 4m + 3 的素因子

列出平方数

前面的 1593.c 程序只能给出答案是几个平方数之和，而对这些平方数是什么一无所知。而 1073.c 程序倒是中规中矩地想要求解这些平方数是什么，但是从 Lagrange 定理得知最多只要四个平方数就够了，所以该程序只求解到三个平方数的情况，其余情况下答案肯定是 4 了。因此，我们将 1073.c 稍做修改，得到 1073b.c 用于列出这些平方数，如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

static int a[5];

int compute(int n)
{
  int i, j, k, l, m = 5;
  int i0 = n / 4, i2 = n, j2, k2, l2;
  for (i = sqrt(n); i2 > i0; i--)
    if ((j2 = n - (i2 = i * i)) == 0) return a[0] = i, 1;
    else for (j = sqrt(j2); j > 0; j--)
      if ((k2 = n - i2 - (j2 = j * j)) == 0) return a[0] = i, a[1] = j, 2;
      else for (k = sqrt(k2); k > 0; k--)
        if ((l2 = n - i2 - j2 - (k2 = k * k)) == 0 && m > 3)
          a[0] = i, a[1] =  j, a[2] = k, m = 3;
        else if (l = sqrt(l2), l * l == l2 && m > 4)
          a[0] = i, a[1] =  j, a[2] = k, a[3] = l, m = 4;
  return m;
}

int main(int args, char* argv[])
{
  int i, n, start = 1, count = 16, k;
  if (args > 1) start = atoi(argv[1]);
  if (args > 2) count = atoi(argv[2]);
  for (n = start; n < start + count; n++)
  {
    k = compute(n);
    printf("%d:%6d:", k, n);
    for (i = 0; i < k; i++) printf(" %d", a[i]);
    puts(k > 4 ? " Error!" : "");
  }
  return 0;
}

上述程序中：

第 5 行的全局静态数组用于记录所求的平方数，数组大小为 5，而不是 4，是为了防止程序有 bug 时造成数组下标越界(第 32 行)。
第 9 行将 m 的初值从 4 改为 5，用以检测程序是否有 bug。
第 9、10 行增加了变量 l 和 l2 用于计算第四个平方数，并相应增加一层循环(第 15 行)。
第 12、14、17 和 19 行相应记录这些平方数于数组 a 中。
第 33 行在输出时检查程序是否有 bug。如果 k > 4 程序肯定有问题，违反了 Lagrange 定理。当然，k <= 4 并不意味着程序就没有问题了。:)

这个程序的运行结果如下所示：

E:\work> 1073b
1:     1: 1
2:     2: 1 1
3:     3: 1 1 1
1:     4: 2
2:     5: 2 1
3:     6: 2 1 1
4:     7: 2 1 1 1
2:     8: 2 2
1:     9: 3
2:    10: 3 1
3:    11: 3 1 1
3:    12: 2 2 2
2:    13: 3 2
3:    14: 3 2 1
4:    15: 3 2 1 1
1:    16: 4

E:\work> 1073b 100001 9
3:100001: 316 12 1
3:100002: 316 11 5
3:100003: 315 27 7
3:100004: 316 12 2
3:100005: 316 10 7
3:100006: 311 57 6
4:100007: 315 27 7 2
3:100008: 314 34 16
2:100009: 315 28

E:\work> 1073b 987654
3:987654: 991 58 47
4:987655: 993 39 9 2
2:987656: 734 670
3:987657: 992 53 28
3:987658: 993 40 3
3:987659: 991 67 33
3:987660: 986 110 58
3:987661: 990 75 44
3:987662: 993 38 13
4:987663: 993 38 13 1
2:987664: 992 60
3:987665: 993 40 4
3:987666: 992 59 11
3:987667: 993 33 23
3:987668: 992 60 2
2:987669: 990 87

E:\work>

如果不知道 Lagrange 定理，也就是说，假设我们不知道要多少个平方数之和才够的话，这道题目看来只好用动态规划算法来求解了。

使用递归求解

键盘农夫园友在 47 楼的评论中介绍了他的随笔“华丽的递归——将正整数表示为平方数之和”。我将该随笔中的 C 语言程序改写如下(1073c.c):

// http://acm.timus.ru/problem.aspx?space=1&num=1073
#include <stdio.h>
 
typedef int bool;
 
const bool true = 1;
const bool false = 0;
 
bool isSquare(int n, int v, int k)
{
  return (n < v) ? false : (n == v) ? true : isSquare(n, v + k + 2, k + 2);
}
 
bool isSquareSum(int n, int m, int v, int k)
{
  if (n < v) return false;
  if (m == 1) return isSquare(n, v, k);
  return isSquareSum(n - v, m - 1, v, k) ? true : isSquareSum(n, m, v + k + 2, k + 2);
}
 
int compute(int n, int m)
{
  return isSquareSum(n, m, 1, 1) ? m : compute(n, m + 1);
}
 
int main(void)
{
  int n;
  scanf("%d", &n);
  printf("%d", compute(n, 1));
  return 0;
}

这个程序本质上和键盘农夫园友的程序是没有区别的。分析如下：

第 9 到 12 行的 isSquare 函数判断 n 是否是不小于 v 的完全平方数。其中 k 是用于计算平方数的辅助变量。
第 14 到 19 行的 isSquareSum 函数判断 n 是否是 m 个不小于 v 的平方数之和。其中 k 是用于计算平方数的辅助变量。
第 21 到 24 行的 compute 函数计算正整数 n 最少可以表示为多少个平方数之和。

上述程序在 Timus Online Judge 网站的运行时间是 0.031 秒，而第一小节中的 1073.c 的运行时间是 0.015 秒。

如果将上述程序作如下改动：

第 9 行的前两个 int 改为 long long
第 14 行的第 1 个和第 3 个 int 改为 long long
第 21 行的第 2 个 int 改为 long long
第 28 行的 int 改为 long long
第 29 行的 %d 改为 %lld

就可以适用于“1593. Square Country. Version 2”，但是运行结果是“Crash (stack overflow)”。

更多的 ACM 题的解法请参见：Timus 目录。

本文链接

Timus 1727. Znaika's Magic Numbers

2011-11-23T12:49:00Z

Timus 1727. Znaika's Magic Numbers 要求将指定的正整数分解为一些不同的正整数的和。

1727. Znaika's Magic Numbers

Time Limit: 0.5 second
Memory Limit: 64 MB

Znaika has many interests. For example, now he is investigating the properties of number sets. Znaika writes down some set consisting of different positive integers (he calls this set agenerating set), calculates the sum of all the written digits, and writes down the result in a special notebook. For example, for a generating set 7, 12, 43, he will write down the number17 = 7 + 1 + 2 + 4 + 3. Znaika is sure that only magic numbers can appear as a result of this operation.

Neznaika laughs at Znaika. He thinks that there is a generating set for every number, and he even made a bet with Znaika that he would be able to construct such a set.

Help Neznaika win the bet and construct a generating set for a given number.

Input

The only input line contains an integer n (0 < n < 10⁵).

Output

If it is possible to construct a generating set for the number n, output the number of elements in this set in the first line. In the second line output a space-separated list of these elements. The elements of the set must be different positive integers strictly less than 10⁵. If there are several generating sets, output any of them. If there are no generating sets, output −1.

Sample

input	output
17	3 7 12 43

Problem Author: Ivan Burmistrov
Problem Source: Ural Regional School Programming Contest 2009

Tags: none

题意

这道题目要求将一个指定的正整数(小于10⁵)分解为一些不同的正整数(也必须小于10⁵)之和，这些正整数的各位数字和加起来刚好等于指定的正整数。

解答

使用 C# 语言解答如下：

using System;

// http://acm.timus.ru/problem.aspx?space=1&num=1727
static class Timus
{
  static void Main()
  {
    int n = int.Parse(Console.ReadLine());
    int count = Compute(ref n), tops = count;
    for (int i = 0; n > 9; i++, n -= 10) count++;
    int tens = count - tops;
    Console.WriteLine(count += ((n > 0) ? 1 : 0));
    for (int i = 99999; tops-- > 0; i--) Console.Write(i + " ");
    while (tens-- > 0) Console.Write("19 28 37 46 ".Substring(tens * 3, 3));
    if (n > 0) Console.Write(n);
  }
  
  static int Compute(ref int n)
  {
    int count = 0;
    for (int sum = 45; n >= 45; )
    {
      n -= sum--;
      if (++count % 10 == 0) sum += 9;
      if (count % 100 == 0) sum += 9;
      if (count % 1000 == 0) sum += 9; 
    }
    return count;
  }
}

分析如下：

首先从 99999 开始往下倒数，直到 n 小于 45。注意，99999 的各位数字之和刚好等于 45，这也是最大的各位数字之和了。
然后利用 19、28、37、46 这四个各位数字之和刚好为 10 的数字。
最后 n 必然小于 10，如果 n 不为零的话，直接输出 n。
Compute 方法就是执行从 99999 开始往下倒数的过程。其各位数字和是很有规律的，也就是从 45 开始往下递减，每遇到整十、整百、整千再加 9。

此外，还可以使用随机算法，如下所示：

using System;
using System.Linq;
using System.Collections.Generic;

// http://acm.timus.ru/problem.aspx?space=1&num=1727
static class Timus
{
  static void Main()
  {
    var n = int.Parse(Console.ReadLine());
    var set = Compute(ref n);
    var count = set.Count;
    for (var i = 0; n > 9; i++, n -= 10) count++;
    var tens = count - set.Count;
    Console.WriteLine(count += ((n > 0) ? 1 : 0));
    foreach (var i in set) Console.Write(i + " ");
    while (tens-- > 0) Console.Write("19 28 37 46 ".Substring(tens * 3, 3));
    if (n > 0) Console.Write(n);
    Console.WriteLine();
  }
  
  static HashSet<int> Compute(ref int n)
  {
    var set = new HashSet<int>();
    for (var rand = new Random(); n >= 45; )
    {
      var k = rand.Next(100, 100000);
      if (set.Add(k)) n -= k.ToString().Select(x => x - '0').Sum();
    }
    return set;
  }
}

这个程序使用 HashSet 保存随机生成的正整数，以便丢弃重复的正整数，以及稍后输出这些正整数。注意第 28 行使用 Select 及 Sum 扩展方法进行各位数字求和。

第一个程序运行时间是 0.14 秒，第二个程序也不慢，运行时间是 0.156 秒。

让我们进行一下测试吧：

using System;
using System.Linq;
using System.Diagnostics;

static class Tester
{
  static void Main(string[] args)
  {
    var n = (args.Length == 0) ? 100000000 : int.Parse(args[0]);
    Run(n, DigitsSum1);
    Run(n, DigitsSum2);
  }
  
  static void Run(int n, Func<int, int> func)
  {
    var timer = Stopwatch.StartNew();
    long sum = 0;
    for (var i = 0; i <= n; i++) sum += func(i);
    timer.Stop();
    Console.WriteLine("{0} {1:N0} {2:N0}", timer.Elapsed, n, sum);
  }
  
  static int DigitsSum1(this int n)
  {
    var sum = 0;
    for (; n > 0; n /= 10) sum += n % 10;
    return sum;
  }
  
  static int DigitsSum2(this int n)
  {
    return n.ToString().Select(x => x - '0').Sum();
  }
}

这个程序的运行结果如下所示：

E:\work>tester
00:00:20.3631972 100,000,000 3,600,000,001
00:00:58.6052102 100,000,000 3,600,000,001

看来使用 Linq 进行求和也不会很慢。

返回目录

本文链接

Timus 1149. Sinus Dances

2011-11-17T08:08:00Z

Timus 1149. Sinus Dances 要求输出特定格式的字符串。

1149. Sinus Dances

Time Limit: 1.0 second
Memory Limit: 16 MB

Let A_n = sin(1–sin(2+sin(3–sin(4+…sin(n))…)
Let S_n = (…(A₁+n)A₂+n–1)A₃+…+2)A_n+1
For given N print S_N

Input

One integer N. 1 ≤ N ≤ 200

Output

Line containing S_N

Sample

input	output
3	((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1

Problem Author: Vladimir Gladkov
Problem Source: Ural Collegiate Programming Contest, April 2001, Perm, Test Round

Tags: problem for beginners

C # 语言解答如下：

using System;

// http://acm.timus.ru/problem.aspx?space=1&num=1149
static class Timus
{
  const int MAX = 200;
  static char[] msg = "sin()+-".ToCharArray();
  static char[] A = new char[MAX * 10];
  static char[] S = new char[MAX * 5 * MAX];
  
  static void Main()
  {
    Console.WriteLine(S, 0, MakeS(int.Parse(Console.ReadLine())));
  }
  
  static int MakeS(int n)
  {
    var count = 0;
    while (count < n - 1) S[count++] = msg[3];  // '('
    for (int k, i = 1; i <= n; i++, count++)
    {
      var N = (n - i + 1).ToString().ToCharArray();
      Array.Copy(A, 0, S, count, k = MakeA(i)); // Ai
      S[count += k] = msg[5];                   // '+'
      Array.Copy(N, 0, S, ++count, N.Length);   // n - i + 1
      S[count += N.Length] = msg[4];            // ')'
    }
    return --count; // 去掉最后 ')'
  }

  static int MakeA(int n)
  {
    var count = 0;
    for (var i = 1; i <= n; i++, count++)
    {
      var N = i.ToString().ToCharArray();
      Array.Copy(msg, 0, A, count, 4);                  // "sin("
      Array.Copy(N, 0, A, count += 4, N.Length);        // i
      A[count += N.Length] = msg[(i % 2 == 0) ? 5 : 6]; // '+' or '-'
    }
    count--; // 覆盖最后 '+' or '-'
    for (var i = 0; i < n; i++) A[count++] = msg[4];    // ')'
    return count;
  }
}

这道题目和解答都非常简单，就不解释了。

返回目录

本文链接

C# I/O 助手类

2011-11-16T02:50:00Z

在使用 C# 语言解 ACM 题的时候，如果能够有一个 ReadInt32 方法直接从标准输入读取整数比较方便的。下面就是一个 I/O 助手类 IOHelper：

namespace Skyiv
{
  using System;
  using System.IO;
  using System.Text;

  sealed class IOHelper : IDisposable
  {
    static readonly Encoding Encoding = Encoding.ASCII; // or UTF8 ?
    static readonly byte[] EOLS = Encoding.GetBytes(Environment.NewLine);
    static readonly byte[] BLANKS = { 9, 10, 13, 32 }; // tab,lf,cr,space
    static readonly byte EOF = 0; // assume '\0' not in input file
    
    byte[] buf = new byte[32]; // for Write(int n)
    byte[] buffer = new byte[64 * 1024];
    int current = 0;
    int count = 0;
    BinaryReader reader;
    BinaryWriter writer;
    
    public IOHelper()
      : this(Console.OpenStandardInput(), Console.OpenStandardOutput())
    {}
    
    public IOHelper(Stream reader, Stream writer)
    {
      this.reader = new BinaryReader(reader);
      this.writer = new BinaryWriter(writer);
    }
    
    byte ReadByte()
    {
      if (current >= count)
      {
        count = reader.Read(buffer, current = 0, buffer.Length);
        if (count == 0) return EOF;
      }
      return buffer[current++];
    }
    
    public static byte[] GetBytes(string str)
    {
      return Encoding.GetBytes(str);
    }
    
    public int ReadInt32()
    {
      var n = 0;
      var ok = false;
      for (byte b; (b = ReadByte()) != EOF; )
      {
        if (Array.IndexOf(BLANKS, b) >= 0)
          if (ok) break;
          else continue;
        n = n * 10 + (b - '0');
        ok = true;
      }
      return n;
    }
    
    public int ReadLine(byte[] buffer)
    {
      var n = 0;
      while (n < buffer.Length)
      {
        var b = ReadByte();
        if (b == EOLS[0])
        {
          if (EOLS.Length == 2 && ReadByte() != EOLS[1])
            throw new InvalidDataException("Invalid EOL");
          break;
        }
        buffer[n++] = b;
      }
      return n;
    }

    public void Write(int n)
    {
      if (n == 0) { writer.Write((byte)'0'); return; }
      var i = buf.Length;
      for (; n > 0; n /= 10) buf[--i] = (byte)((n % 10) + '0');
      Write(buf, i, buf.Length - i);
    }
    
    public void Write(byte[] buffer, int index, int count)
    {
      writer.Write(buffer, index, count);
    }
    
    public void Write(string str)
    {
      var buffer = Encoding.GetBytes(str);
      writer.Write(buffer, 0, buffer.Length);
    }
    
    public void WriteSpace()
    {
      writer.Write(BLANKS, 3, 1);
    }
    
    public void WriteLine()
    {
      writer.Write(EOLS, 0, EOLS.Length);
    }
    
    public void Dispose()
    {
      if (reader != null) reader.Close();
      if (writer != null) writer.Close();
    }
  }
}

此外，IOHelper 类还提供以下方法用于处理字符串：

public int ReadLine(byte[] buffer)
public void Write(byte[] buffer, int index, int count)

类似于 C/C++ 语言，这两个方法仅仅把字符串当作字节数组处理，使用 ASCII 码。而不是象 C# 语言中字符串是使用 Unicode 进行编码。

下面是一个使用示例，题目来源请参见“I-Keyboard”这篇随笔。

namespace Skyiv.Ben.Acm
{
  using System;

  // http://www.spoj.pl/problems/IKEYB/
  sealed class Ikeyb
  {
    const int MAX = 90;
    
    static int[,] cost = new int[MAX + 1, MAX + 1];
    static int[,] price = new int[MAX + 1, MAX + 1];
    static int[,] index = new int[MAX + 1, MAX + 1];
    static int[] F = new int[MAX];
    static byte[] keys = new byte[MAX];
    static byte[] letters = new byte[MAX];
    static byte[] message1 = IOHelper.GetBytes("Keypad #");
    static byte[] message2 = IOHelper.GetBytes(": ");
    
    static IOHelper helper;

    static void Main()
    {
      using (helper = new IOHelper())
      {
        var runner = new Ikeyb();
        var T = helper.ReadInt32();
        for (var n = 1; n <= T; n++) runner.Run(n);
      }
    }

    void Run(int n)
    {
      var K = helper.ReadInt32();
      var L = helper.ReadInt32();
      helper.ReadLine(keys);
      helper.ReadLine(letters);
      for (var i = 0; i < L; i++) F[i] = helper.ReadInt32();
      Initialize(K, L);
      Compute(K, L);
      helper.Write(message1, 0, message1.Length);
      helper.Write(n);
      helper.Write(message2, 0, 1);
      helper.WriteLine();
      Output(K, L);
      helper.WriteLine();
    }
    
    void Initialize(int K, int L)
    {
      for (var i = 0; i <= K; i++)
        for (var j = 1; j <= L; j++)
          price[i, j] = int.MaxValue / 2;
      for (var i = 1; i <= L; i++)
        for (var j = i; j <= L; j++)
          cost[i, j] = cost[i, j - 1] + (j - i + 1) * F[j - 1];
    }
    
    void Compute(int K, int L)
    {
      for (var i = 1; i <= K; i++)
        for (var j = i; j <= L; j++)
          for (var n = 1; n <= j - i + 1; n++)
          {
            var sum = price[i - 1, j - n] + cost[j - n + 1, j];
            if (sum <= price[i, j])
            {
              price[i, j] = sum;
              index[i, j] = n;
            }
          }
    }

    void Output(int K, int L)
    {
      if (K == 0) return;
      var n = index[K--, L];
      Output(K, L - n);
      helper.Write(keys, K, 1);
      helper.Write(message2, 0, message2.Length);
      helper.Write(letters, L - n, n);
      helper.WriteLine();
    }
  }
}

如果给出以下输入：

上述程序将产生以下输出：

Keypad #1:
*: ABCD
#: E

注意上述输出其实是有问题的，正确的输出应该分为 AB 和 CDE 两组。但是程序本身是没有问题的，而是输入数据有问题。因为原来的题目中限定各个字母出现的频率不能超过 100000。

本文链接

Timus 1837. Isenbaev's Number

2011-11-14T13:10:00Z

Timus 1837. Isenbaev's Number 要求计算 Isenbaev 数。

1837. Isenbaev's Number

Time Limit: 0.5 second
Memory Limit: 64 MB

Vladislav Isenbaev is a two-time champion of Ural, vice champion of TopCoder Open 2009, and absolute champion of ACM ICPC 2009. In the time you will spend reading this problem statement Vladislav would have solved a problem. Maybe, even two…

Since Vladislav Isenbaev graduated from the Specialized Educational and Scientific Center at Ural State University, many of the former and present contestants at USU have known him for quite a few years. Some of them are proud to say that they either played in the same team with him or played in the same team with one of his teammates…

Let us define Isenbaev's number as follows. This number for Vladislav himself is 0. For people who played in the same team with him, the number is 1. For people who weren't his teammates but played in the same team with one or more of his teammates, the number is 2, and so on. Your task is to automate the process of calculating Isenbaev's numbers so that each contestant at USU would know their proximity to the ACM ICPC champion.

Input

The first line contains the number of teams n (1 ≤ n ≤ 100). In each of the following n lines you are given the names of the three members of the corresponding team. The names are separated with a space. Each name is a nonempty line consisting of English letters, and its length is at most 20 symbols. The first letter of a name is capital and the other letters are lowercase.

Output

For each contestant mentioned in the input data output a line with their name and Isenbaev's number. If the number is undefined, output “undefined” instead of it. The contestants must be ordered lexicographically.

Sample

input	output
7 Isenbaev Oparin Toropov Ayzenshteyn Oparin Samsonov Ayzenshteyn Chevdar Samsonov Fominykh Isenbaev Oparin Dublennykh Fominykh Ivankov Burmistrov Dublennykh Kurpilyanskiy Cormen Leiserson Rivest	Ayzenshteyn 2 Burmistrov 3 Chevdar 3 Cormen undefined Dublennykh 2 Fominykh 1 Isenbaev 0 Ivankov 2 Kurpilyanskiy 3 Leiserson undefined Oparin 1 Rivest undefined Samsonov 2 Toropov 1

input

output

7
Isenbaev Oparin Toropov
Ayzenshteyn Oparin Samsonov
Ayzenshteyn Chevdar Samsonov
Fominykh Isenbaev Oparin
Dublennykh Fominykh Ivankov
Burmistrov Dublennykh Kurpilyanskiy
Cormen Leiserson Rivest

Ayzenshteyn 2
Burmistrov 3
Chevdar 3
Cormen undefined
Dublennykh 2
Fominykh 1
Isenbaev 0
Ivankov 2
Kurpilyanskiy 3
Leiserson undefined
Oparin 1
Rivest undefined
Samsonov 2
Toropov 1

Problem Author: folklore
Problem Source: Ural Championship 2011

Tags: graph theory

题意

这道题目是说俄罗斯乌拉尔大学有一个叫 Isenbaev 的牛人，他是 TopCoder Open 2009 和 ACM IPCP 2009 竞赛的双料冠军。许多人都以和他一同组队参赛为荣。退而其次，和他的队友一同参赛也是很有面子的。我们定义 Isenbaev 数如下：Isenbaev 他自己是 0，他的队友是 1。如果不是 Isenbaev 的队友，而是 Isenbaev 的队友参加的团队的成员，则是 2。以此类推。给出一些参赛队伍的名单，要求计算出这些队伍中每个人的 Isenbaev 数。

解答

下面就解答这道题目的是 C# 语言源程序：

using System;
using System.Collections.Generic;

// http://acm.timus.ru/problem.aspx?space=1&num=1837
static class Timus
{
  enum State { Initial, Prepare, Ready, Done };

  static readonly string VIP = "Isenbaev";
  static SortedDictionary<string, int> ranks;
  static string[][] teams;
  static State[] states;
  
  static void Main()
  {
    Initialize();
    Compute();
    foreach (var kvp in ranks) Console.WriteLine(kvp.Key + " "
      + ((kvp.Value < 0) ? "undefined" : kvp.Value.ToString()));
  }
  
  static void Initialize()
  {
    ranks = new SortedDictionary<string, int>();
    teams = new string[int.Parse(Console.ReadLine())][];
    states = new State[teams.Length]; // value is: Initial
    for (var i = 0; i < teams.Length; i++)
      foreach (var name in teams[i] = Console.ReadLine().Split())
      {
        ranks[name] = (name == VIP) ? 0 : -1;
        if (name == VIP) states[i] = State.Ready;
      }
  }
  
  static void Compute()
  {
    for (var rank = 1; ; rank++)
    {
      var done = true;
      for (var i = 0; i < states.Length; i++)
        if (states[i] == State.Ready)
        {
          foreach (var name in teams[i]) Compute(name, rank);
          states[i] = State.Done;
          done = false;
        }
      if (done) break;
      states.Replace(State.Prepare, State.Ready);
    }
  }
  
  static void Compute(string name, int rank)
  {
    if (ranks[name] >= 0) return;
    ranks[name] = rank;
    for (var i = 0; i < states.Length; i++)
      if (states[i] == State.Initial)
        foreach (var name2 in teams[i])
          if (name2 == name) states[i] = State.Prepare;
  }
  
  static void Replace<T>(this IList<T> c, T a, T b)
  {
    for (var i = 0; i < c.Count; i++)
      if (EqualityComparer<T>.Default.Equals(c[i], a)) c[i] = b;
  }
}

上述程序按照 Isenbave 数从小到大层次递进求解，分析如下：

line 10: 静态字段 ranks 表示各人的 Isenbave 数，其类型是 SortedDictionay，键就是人的姓名，值是 Isenbave 数。
line 11: 静态字段 teams 表示各参赛队伍，其类型是二维锯齿形数组。因为每个队伍的人数是不固定的。(题目中每个队伍均为三人，我们的程序不受这个限制)
line 12: 静态字段 states 表示求解过程中各参赛队伍的状态，计有“初始、预备、就绪、完毕”四种。请参见第 7 行的 State 枚举类型。
line 16 - 19: 首先调用 Initialize 方法读入数据并进行初始化，然后调用 Compute 方法求解，最后输出结果。
line 22 - 33: Initialize 方法。首先初始化上面提到的三个字段，注意 states 数组各元素的值被默认初始化为 State.Initial。然后循环读入各参赛队伍的数据，并且根据读入的人员是否为 Isenbave 进行相应处理。如果某个参赛队伍中有 Isenbave，该队伍的状态就设置为 State.Ready。
line 35 - 50: Compute 方法。从 1 开始递增 Isenbave 数进行求解，遍历各个参赛队伍，如果某个队伍的状态为 State.Ready 就遍历该队伍中的每个成员，调用下面要讲解的重载的 Compute 方法进行处理，处理后的队伍的状态改为 State.Done。最后，将处理后的状态为 State.Prepare 的队伍的都改为 State.Ready 状态，以便下次循环时继续求解。
line 52 - 60: 重载的 Compute 方法。如果队伍中某人的 Isenbave 数已经求出来了，就什么也不做立即返回。否则，设置他的 Isenbave 数。然后遍历状态为 State.Initial 的队伍，如果某人是该队伍的成员，则这个队伍的状态设置为 State.Prepare，以便在下个层次的循环中进行处理。
line 62 - 66: Replace 扩展方法。该方法用于对列表中的特定元素进行替换。可以作为一个小小的工具使用。

另一种解法

使用 List 代替数组的另外一种解法：

using System;
using System.Collections.Generic;

// http://acm.timus.ru/problem.aspx?space=1&num=1837
static class Timus
{
  static readonly string VIP = "Isenbaev";
  static SortedDictionary<string, int> ranks;
  static List<string[]> initial, prepare, ready;
  
  static void Main()
  {
    Initialize();
    Compute();
    foreach (var kvp in ranks) Console.WriteLine(kvp.Key + " "
      + ((kvp.Value < 0) ? "undefined" : kvp.Value.ToString()));
  }
  
  static void Initialize()
  {
    ranks = new SortedDictionary<string, int>();
    initial = new List<string[]>();
    ready = new List<string[]>();
    for (var i = int.Parse(Console.ReadLine()); i > 0; i--)
    {
      var team = Console.ReadLine().Split();
      var isReady = false;
      foreach (var name in team)
      {
        ranks[name] = (name == VIP) ? 0 : -1;
        if (name == VIP) isReady = true;
      }
      (isReady ? ready : initial).Add(team);
    }
  }
  
  static void Compute()
  {
    for (var rank = 1; ready.Count != 0; rank++, ready = prepare)
    {
      prepare = new List<string[]>();
      foreach (var team in ready)
        foreach (var name in team)
          Compute(name, rank);
    }
  }
  
  static void Compute(string name, int rank)
  {
    if (ranks[name] >= 0) return;
    ranks[name] = rank;
    for (var i = 0; i < initial.Count; i++)
      foreach (var name2 in initial[i])
      {
        if (name2 != name) continue;
        prepare.Add(initial[i]);
        initial.RemoveAt(i--);
        break;
      }
  }
}

在这个程序中，取消了二维锯齿数组 teams 和一维数组 states，使用三个 List 代替，即: initial、prepare 和 ready，分别对应原来的 Initial、Prepare 和 Ready 状态。而 Done 状态不再需要了，ready 中的队伍处理完毕后，直接将 prepare 改为 ready 进入下一层次的循环。这个程序在大数据量的情况下可能会比第一个程序快一点。

扩展阅读

维基百科中的“埃尔德什数(Erdős number)”应该是这道题目的背景。与此相关的还有“六度分隔理论(Small world experiment)”。

返回目录

本文链接

I-Keyboard

2011-11-09T14:46:00Z

问题描述

Sphere Online Judge (SPOJ) 网站的第14道题目是：“I-Keyboard”，如下所示：

SPOJ Problem Set (classical)
14. I-Keyboard
Problem code: IKEYB

Most of you have probably tried to type an SMS message on the keypad of a cellular phone. It is sometimes very annoying to write longer messages, because one key must be usually pressed several times to produce a single letter. It is due to a low number of keys on the keypad. Typical phone has twelve keys only (and maybe some other control keys that are not used for typing). Moreover, only eight keys are used for typing 26 letters of an English alphabet. The standard assignment of letters on the keypad is shown in the left picture:

1	2 abc	3 def
4 ghi	5 jkl	6 mno
7 pqrs	8 tuv	9 wxyz
*	0 space	#

1	2 abcd	3 efg
4 hijk	5 lm	6 nopq
7 rs	8 tuv	9 wxyz
*	0 space	#

There are 3 or 4 letters assigned to each key. If you want the first letter of any group, you press that key once. If you want the second letter, you have to press the key twice. For other letters, the key must be pressed three or four times. The authors of the keyboard did not try to optimise the layout for minimal number of keystrokes. Instead, they preferred the even distribution of letters among the keys. Unfortunately, some letters are more frequent than others. Some of these frequent letters are placed on the third or even fourth place on the standard keyboard. For example, S is a very common letter in an English alphabet, and we need four keystrokes to type it. If the assignment of characters was like in the right picture, the keyboard would be much more comfortable for typing average English texts.

ACM have decided to put an optimised version of the keyboard on its new cellular phone. Now they need a computer program that will find an optimal layout for the given letter frequency. We need to preserve alphabetical order of letters, because the user would be confused if the letters were mixed. But we can assign any number of letters to a single key.

Input

There is a single positive integer T on the first line of input (equal to about 2000). It stands for the number of test cases to follow. Each test case begins with a line containing two integers K, L (1 <= K <= L <= 90) separated by a single space. K is the number of keys, L is the number of letters to be mapped onto those keys. Then there are two lines. The first one contains exactly K characters each representing a name of one key. The second line contains exactly L characters representing names of letters of an alphabet. Keys and letters are represented by digits, letters (which are case-sensitive), or any punctuation characters (ASCII code between 33 and 126 inclusively). No two keys have the same character, no two letters are the same. However, the name of a letter can be used also as a name for a key.

After those two lines, there are exactly L lines each containing exactly one positive integer F₁, F₂, ... F_L. These numbers determine the frequency of every letter, starting with the first one and continuing with the others sequentially. The higher number means the more common letter. No frequency will be higher than 100000.

Output

Find an optimal keyboard for each test case. Optimal keyboard is such that has the lowest "price" for typing average text. The price is determined as the sum of the prices of each letter. The price of a letter is a product of the letter frequency (F_i) and its position on the key. The order of letters cannot be changed, they must be grouped in the given order.

If there are more solutions with the same price, we will try to maximise the number of letters assigned to the last key, then to the one before the last one etc.

More formally, you are to find a sequence P₁, P₂, ... P_L representing the position of every letter on a particular key. The sequence must meet following conditions:

P₁ = 1
for each i>1, either P_i = P_i-1+1 or P_i = 1
there are at most K numbers P_i such that P_i = 1
the sum of products S_P = Sum[i=1..l] F_i.P_i is minimal
for any other sequence Q meeting these criteria and with the same sum S_Q = S_P, there exists suchM, 1 <= M <= L that for any J, M<J <= L, P_J = Q_J, and P_M>Q_M.

The output for every test case must start with a single line saying Keypad #I:, where I is a sequential order of the test case, starting with 1. Then there must be exactly K lines, each representing one letter, in the same order that was used in input. Each line must contain the character representing the key, a colon, one space and a list of letters assigned to that particular key. Letters are not separated from each other.

Print one blank line after each test case, including the last one.

Example

Sample Input:
1
8 26
23456789
ABCDEFGHIJKLMNOPQRSTUVWXYZ
3371
589
1575
1614
6212
971
773
1904
2989
123
209
1588
1513
2996
3269
1080
121
2726
3083
4368
1334
518
752
427
733
871
Sample Output:
Keypad #1:
2: ABCD
3: EFG
4: HIJK
5: LM
6: NOPQ
7: RS
8: TUV
9: WXYZ

Warning: large Input/Output data, be careful with certain languages

Added by:	Adrian Kosowski
Date:	2004-05-09
Time limit:	5s
Source limit:	50000B
Languages:	All
Resource:	ACM Central European Programming Contest, Prague 2000

这道题目是说使用手机上的数字小键盘发送短信的话，有些英文字母需要多次按同一个数字键才能输入。比如很常用的字母“s”就需要按四次“7”键才行。我们的任务是写一个程序，在不改变字母的顺序的情况下，将这些字母分配到各个按键上，使用得输入信息的总的按键次数最少。输入信息中各个字母出现的频率是已经给定的。

问题解答

下面就是使用动态规划算法解答的 C 语言源程序：

#include <stdio.h>
#include <string.h>

#define MAX (90 + 1)

static int cost[MAX][MAX], price[MAX][MAX], index[MAX][MAX];

void initialize(int L, int F[])
{
  memset(price, 0x40, sizeof(price));
  price[0][0] = 0;
  for (int i = 1; i <= L; i++)
    for (int j = i; j <= L; j++)
      cost[i][j] = cost[i][j - 1] + (j - i + 1) * F[j - 1];
}

void compute(int K, int L)
{
  for (int i = 1; i <= K; i++)
    for (int j = i; j <= L; j++)
      for (int n = 1; n <= j - i + 1; n++)
      {
        int sum = price[i - 1][j - n] + cost[j - n + 1][j];
        if (sum <= price[i][j]) price[i][j] = sum, index[i][j] = n;
      }
}

void output(int K, int L, char keys[], char letters[])
{
  if (K == 0) return;
  output(K - 1, L - index[K][L], keys, letters);
  printf("%c: ",keys[K - 1]);
  for (int i = L - index[K][L]; i < L; i++) putchar(letters[i]);
  puts("");
}

int main(void)
{
  int F[MAX - 1], T;
  scanf("%d", &T);
  for (int K, L, n = 1; n <= T; n++)
  {
    char keys[MAX], letters[MAX];
    scanf("%d%d%s%s", &K, &L, keys, letters);
    for (int i = 0; i < L; i++) scanf("%d", F + i);
    initialize(L, F);
    compute(K, L);
    printf("Keypad #%d:\n", n);
    output(K, L, keys, letters);
    puts("");
  }
  return 0;
}

假设我们有以下输入：

运行该程序将得到以下输出：

Keypad #1:
1: A
2: BCDE
3: FGHI

算法分析

使用上一节的输入数据运行该程序，主要的运行状态如下所示：

上述程序中：

K 是按键的个数。L 是要分配到各个按键中的字符的个数。T 是测试案例的个数。一维数组 F 的大小为 L，保存各个字符出现的频率。
cost 是大小为 L x L 的二维数组，cost[i][j] 表示第 i 到第 j 个字符分配到某个按键上的代价，即输入这 j - i + 1 个字符(乘上它们出现的频率)的总的按键次数。注意，主对角线上的值就是各个字符出现的频率。这体现在源程序中 initialize 函数的第 12 到第 14 行。初始化之后，cost 的数组的值就不再改变了。
price 是大小为 K x L 的二维数组，price[i][j] 表示前 j 个字符分配在前 i 个按建上的最小代价。上图中的 A 的值是大约是 INT_MAX 的一半。第一个字符一定是分配在第一个按键上的，而不管第一个字符出现的频率如何(实际上第一个字符的频率可以设置为任何正数，而不影响程序的运行结果)。所以 price[0][0] 初始化设置为 0，而 price 数组的其他值初始化为一个比较大的数。
index 是大小为 K x L 的二维数组，index[K][L] 表示第 K 个(最后一个)按键上分配的字符数，然后往回倒算，index[K - 1][L - index[K][L]] 表示第 K - 1 个按键上分配的字符数，... 一直倒算到第 1 个按键为止。这体现在源程序第 28 到 35 行的 output 函数中，使用递归是为了以正确的顺序输出这些按键。
程序中最关键的是第 17 到第 26 行的 compute 函数。该函数通过三重循环将问题分角为子任务用动态规划算法求解。子任务是求将 j 个字符分配到 i 个按键上的最小代价。
第 19 行：i 从 1 到 K 循环逐步求解。总共有 K 个按键。
第 20 行：j 从 i 到 L 循环逐步求解。总共有 L 个字符，且每个按键至少必须分配一个字符。
第 21 行：n 从 1 到 j - i + 1 逐步求解。注意，这里 n 是指最后一个按键中分配的字符数。
第 23 行：这是最关键的计算最小代价的公式，sum 由两部分组成，第二部分是将第 j - n + 1 到第 j 个字符(总共 n 个)分配到第 i 个按键(也就是该子任务中的最后一个按键)中的最小代价，第一部分就是将该子任务中剩下的 j - n 个字符分配到前 i - 1 个按键中的最小代价。注意，该子任务总共要分配 j 个字符。
第 24 行：如果计算出来的最小代价比原来的小，就更新最小代价数组 price，并同时更新 index 数组，以便将来输出键盘布局。
三重循环完成，表明整个计算任务完成，L 个字符已经分配到 K 个按键中。此时，price[K][L] 表示所求的最小代价，在我们例子中就是 246。

注意，这道题目要求在同等代价下将字符尽量分配到后面的按键中，所以第 24 行比较代价时使用“<=”，以便尽量增加后面按键的字符数。如果将这个程序第 24 行的“<=”改为“<”，则将得到以下输出：

Keypad #1:
1: ABC
2: DE
3: FGHI

此时，策略是在同等代价下将字符尽量分配到前面的按键中。

英语国家手机数字键盘的最优方案

维基百科网站的 Letter frequency 给出了英语中二十六个字母出现的频率，如下表所示：

Letter	Frequency
a	8.167%
b	1.492%
c	2.782%
d	4.253%
e	12.702%
f	2.228%
g	2.015%
h	6.094%
i	6.966%
j	0.153%
k	0.772%
l	4.025%
m	2.406%
n	6.749%
o	7.507%
p	1.929%
q	0.095%
r	5.987%
s	6.327%
t	9.056%
u	2.758%
v	0.978%
w	2.360%
x	0.150%
y	1.974%
z	0.074%

根据上表设置相应的输入文件：

1
8 26
23456789
ABCDEFGHIJKLMNOPQRSTUVWXYZ
8167
1492
2782
4253
12702
2228
2015
6094
6966
153
772
4025
2406
6749
7507
1929
95
5987
6327
9056
2758
978
2360
150
1974
74

运行结果如下所示：

Keypad #1:
2: AB
3: CD
4: EFG
5: HIJK
6: LM
7: NOPQ
8: RS
9: TUVWXYZ

数字“9”键上居然有七个英文字母，可见最后几个英文字母出现的频率很低。看来在英文国家手机的数字键盘应该如上设置才能够更好地输入信息。当然，我们输入中文又是另外一回事了，用拼音和用五笔输入法，各个字母的频率也是不同的。其实手机向智能化发展，越来越多地使用全键盘了，不再使用数学小键盘。

更好的算法

我的 C 程序在 SPOJ 网站上提交的结果如下所示：

也就是说我的程序运行时间是 0.57 秒，但是这道题目前最好的运行时间是 0.21 秒：

这肯定有更好的算法。有哪位园友知道更好的算法，请在评论中告诉我。谢谢！

算法和数据结构目录

本文链接

Life, the Universe, and Everything

2011-11-02T01:53:00Z

问题描述

Sphere Online Judge (SPOJ) 网站的第一道题目是：“Life, the Universe, and Everything”，如下所示：

SPOJ Problem Set (classical)
1. Life, the Universe, and Everything
Problem code: TEST

Your program is to use the brute-force approach in order to find the Answer to Life, the Universe, and Everything. More precisely... rewrite small numbers from input to output. Stop processing input after reading in the number 42. All numbers at input are integers of one or two digits.

Example

Input:
1
2
88
42
99
Output:
1
2
88

Added by:	Michał Małafiejski
Date:	2004-05-01
Time limit:	10s
Source limit:	50000B
Languages:	All
Resource:	Douglas Adams, The Hitchhiker's Guide to the Galaxy

你要求写一个程序来暴力破解生命、宇宙及任何事情的终极答案。准确地说，就是把一些很小的数从输入复制到输出，遇到 42 就停止。输入的所有数都是一位或者两位的整数。这道题目的背景故事来源于英国作家道格拉斯·亚当斯所著的长篇科幻小说《银河系漫游指南》，书中说：亚瑟·丹特在马格西亚上被告知，地球其实只是一个实验。原来许多百万年前，老鼠其实是一种超智慧生物，它们建造了一部超级电脑深思，它们问超级电脑，生命、宇宙以及任何事情的终极答案是什么，经过一段长时间的计算，深思告诉老鼠的后人答案是 42，深思解释它只能计算出答案是什么，但答案的原因必须由另一部更高智能的电脑才能解释，而该部电脑就是地球。2005年6月四川科学技术出版社出版了《银河系漫游指南》，2011年8月上海译文出版社重新出版了这本科幻小说，书名改为《银河系搭车客指南》：

问题解答

这道题目是 SPOJ 网站的第一道题目，作为入门的测试，以便让用户熟悉在该网站解题的步骤，所以完全没有难度，其 C# 语言解答如下所示：

using System;

// http://www.spoj.pl/problems/TEST/
static class Test
{
  static void Main()
  {
    for (string s; (s = Console.ReadLine()) != "42"; Console.WriteLine(s)) ;
  }
}

翻译为对应的 F# 语言：

open System

let mutable s = Console.ReadLine()
while s <> "42" do
  printfn "%s" s
  s <- Console.ReadLine()

F# 不是纯函数语言，而是多范式的编程语言。上述 F# 程序使用命令范式，而改为函数式编程则如下所示，使用尾递归：

let rec test() =
  let s = System.Console.ReadLine()
  if s <> "42" then
    printfn "%s" s
    test()

test()

还可以把函数作为参数传递，也就是所谓的高阶函数：

let rec test readLine =
  let s = readLine()
  if s <> "42" then
    printfn "%s" s
    test readLine

test System.Console.ReadLine

注意上述 F# 程序上最后一行传递的是参数是 Console.ReadLine 函数本身，而不是该函数的返回值。这样才能够不断读取输入行。第一行定义 test 函数时也不用指明形参 readLine 的类型，F# 语言编译器能够根据上下文推断出正确的类型。在 C# 语言中函数是不能直接作为参数传递的，必须使用委托或者 Lambda 表达式。

而 Ruby 语言的解答就非常简单了，只有一句话：

while (num = gets).to_i != 42 do puts num end

Perl 语言的解答也非常简单：

while (($_ = <>) != 42) { print $_; }

下面是 Python 语言的解答：

n = int(input())
while n != 42:
  print(n)
  n = int(input())

Java 语言的解答如下所示：

import java.io.*;

class Test
{
  public static void main(String[] args) throws java.lang.Exception
  {
    String s;
    BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
    while (!(s = r.readLine()).startsWith("42")) System.out.println(s);
  }
}

当然少不了 C 语言解答：

#include <stdio.h> 

int main(void)
{ 
  for(int x; scanf("%d",&x) > 0 && x != 42; printf("%d\n", x)) ; 
  return 0; 
}

还有 C++ 语言解答：

#include <iostream>

using namespace std;
 
int main()
{
  for (int x; cin >> x, x != 42; cout << x << endl) ;
  return 0;
}

所有以上程序都在 SPOJ 网站提交通过。该网站运行在 Linux 操作系统下，支持四十多种编程语言。

在线集成开发环境

ideone.com 是一个“Onle IDE & Debugging Tool”。她的范例页面提供了很多编程语言的示例程序，这些示例程序都是用于解答以上问题的。这个网站和 SPOJ 网站的后台都是 Sphere Research Labs。

本文链接

Timus 1567. SMS-spam

2011-10-30T12:01:00Z

Timus 1567. SMS-spam 要求计算手机短信的收费情况。

Timus 1567. SMS-spam

Time Limit: 1.0 second
Memory Limit: 64 MB

Petr, a student, decided to start his own business. He offers SMS advertising services to the business owners renting offices in the newly built “Prisma” tower. If an office owner wants to use the service, he devises a slogan and Petr texts it from his personal phone to thousands of Ekaterinburg citizens (he already bought the pirated list of mobile phone numbers). The cost of each slogan sent is a sum of costs of each character typed. Cost of an individual character is determined according to a very simple scheme: each tap at the phone's keyboard costs 1 rouble.

Petr's phone doesn't support sophisticated text input technologies, such as T9, and only the english alphabet can be used.

1 abc	2 def	3 ghi
4 jkl	5 mno	6 pqr
7 stu	8 vwx	9 yz
	0 .,!	# _

The “_” character in the table denotes whitespace. If you want to, for example, type “a”, you need to press the “1” button once. To type “k”, you press “4” twice. To type “!”, press “0” three times.

Petr has to apply this simple algorithm to calculate the cost of every slogan he sends. However, Petr is a very busy man (and, as a matter of fact, doesn't bother to learn arithmetics, because he's a Philosophy student). You just have to help Petr, you are his best friend after all.

Input

The single line of input contains the slogan. Slogan consists of words, spaces, commas, full stops and exclamation marks. All the words consist of lowercase english letters. Slogan can't be longer than 1000 characters.

Output

Output a single number representing the cost of the given slogan, according to Petr's pricing.

Sample

input	output
pokupaite gvozdi tolko v kompanii gvozdederov i tovarischi!	114

Problem Author: Denis Musin
Problem Source: The XIIth USU Programing Championship, October 6, 2007

题意

这道题目是讲俄罗斯一位学生 Petr 的创业故事。Petr 购买了数千个叶卡特琳堡市民的手机号码，以便提供发送垃圾短信服务(想不到俄罗斯也有出售非法的手机号码清单，也有垃圾短信)。Petr 是通过他的手机来发送短信的，按照他的手机键盘(跟我们常见的手机键盘的布局有些不同)，“a”需要按“1”键一次，“k”需要按“4”键两次，“!”需要按“0”键三次。Petr 是按照按键次数来收费的，每一次按键收费一卢布。我们的任务就是写一个程序计算每条短信应该收多少钱。

解答

下面是 C# 源程序：

01:  using System;
02:  using System.Collections.Generic;
03:  
04:  namespace Skyiv.Ben.Timus
05:  {
06:    // http://acm.timus.ru/problem.aspx?space=1&num=1567
07:    sealed class T1567
08:    {
09:      static void Main()
10:      {
11:        var dict = GetPrice();
12:        var sum = 0;
13:        foreach (var c in Console.ReadLine()) sum += dict[c];
14:        Console.WriteLine(sum);
15:      }
16:      
17:      static Dictionary<char, int> GetPrice()
18:      {
19:        var dict = new Dictionary<char, int>();
20:        for (var i = 0; i < 4; i++) dict.Add(".,! "[i], (i % 3) + 1);
21:        for (var i = 0; i < 26; i++) dict.Add((char)(i + 'a'), (i % 3) + 1);
22:        return dict;
23:      }
24:    }
25:  }

上述程序首先构造一个不同字符的收费表，然后再计算该收的费用。注意如果输入中出现了不在收费表的字符，该程序将抛出 KeyNotFoundException。但这是ACM题，我们只要按照题意写程序就行，也就是按照契约编程，不用考虑意外的输入。

下面是 C 源程序：

01:  // http://acm.timus.ru/problem.aspx?space=1&num=1567
02:  
03:  #include <stdio.h>
04:  
05:  int getPrice(char c)
06:  {
07:    if (c == '.' || c == ' ') return 1;
08:    if (c == ',') return 2;
09:    if (c == '!') return 3;
10:    return 1 + (c - 'a') % 3;
11:  }
12:  
13:  int main()
14:  {
15:    int i, sum = 0;
16:    char buf[1001];
17:    gets(buf);
18:    for (i = strlen(buf) - 1; i >= 0; i--)
19:      sum += getPrice(buf[i]);
20:    printf("%d\n", sum);
21:    return 0;
22:  }

上述程序中的 getPrice 函数用来计算每个字符的收费。注意上述程序中的 gets 函数是不安全的，如果输入超出 1000 个字符，将造成缓冲区溢出。同样由于这是 ACM 题，所以不用担心。

下面是 C++ 源程序：

01:  // http://acm.timus.ru/problem.aspx?space=1&num=1567
02:  
03:  #include <iostream>
04:  #include <string>
05:  
06:  using namespace std;
07:  
08:  int getPrice(char c)
09:  {
10:    if (c == '.' || c == ' ') return 1;
11:    if (c == ',') return 2;
12:    if (c == '!') return 3;
13:    return 1 + (c - 'a') % 3;
14:  }
15:  
16:  int main()
17:  {
18:    string buf;
19:    getline(cin, buf);
20:    int sum = 0;
21:    for (string::iterator it = buf.begin(); it < buf.end(); it++)
22:      sum += getPrice(*it);
23:    cout << sum << endl;
24:    return 0;
25:  }

上述程序和 C 程序基本上是一样的，不过 getline 函数是安全的。

下面是 F# 源程序：

01:  // http://acm.timus.ru/problem.aspx?space=1&num=1567
02:  
03:  let getPrice c =
04:    match c with
05:    | '.' | ' ' -> 1
06:    | ',' -> 2
07:    | '!' -> 3
08:    | x -> 1 + (int x - int 'a') % 3
09:  
10:  let pricing str = str |> Seq.map getPrice |> Seq.sum
11:    
12:  System.Console.ReadLine() |> pricing |> printfn "%d"

可以看出 F# 程序最简单明了，Seq.map 根据 getPrice 来计算每个字符的收费，再用 Seq.sum 来求和。

返回目录

本文链接

博客园_银河

C语言常用数据类型的大小

【算法】验证哥德巴赫猜想

【算法】将正整数表示为平方数之和

Timus 1727. Znaika's Magic Numbers

Input

The only input line contains an integer n (0 < n < 10⁵).

Sample

input output

17

3 7 12 43

Problem Author: Ivan Burmistrov
Problem Source: Ural Regional School Programming Contest 2009

Timus 1149. Sinus Dances

Input

One integer N. 1 ≤ N ≤ 200

Output

Line containing S_N

Sample

input output

3

((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1

Problem Author: Vladimir Gladkov
Problem Source: Ural Collegiate Programming Contest, April 2001, Perm, Test Round

C# I/O 助手类

Timus 1837. Isenbaev's Number

I-Keyboard

Life, the Universe, and Everything

Timus 1567. SMS-spam

博客园_银河

C语言常用数据类型的大小

【算法】验证哥德巴赫猜想

【算法】将正整数表示为平方数之和

Timus 1727. Znaika's Magic Numbers

Input The only input line contains an integer n (0 < n < 105).

Sample inputoutput 17 3 7 12 43 Problem Author: Ivan BurmistrovProblem Source: Ural Regional School Programming Contest 2009

Timus 1149. Sinus Dances

Input One integer N. 1 ≤ N ≤ 200

Output Line containing SN

Sample inputoutput 3 ((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1 Problem Author: Vladimir Gladkov Problem Source: Ural Collegiate Programming Contest, April 2001, Perm, Test Round

C# I/O 助手类

Timus 1837. Isenbaev's Number

I-Keyboard

Life, the Universe, and Everything

Timus 1567. SMS-spam

Input

The only input line contains an integer n (0 < n < 10⁵).

Sample

input output

17

3 7 12 43

Problem Author: Ivan Burmistrov
Problem Source: Ural Regional School Programming Contest 2009

Input

One integer N. 1 ≤ N ≤ 200

Output

Line containing S_N

Sample

input output

3

((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1

Problem Author: Vladimir Gladkov
Problem Source: Ural Collegiate Programming Contest, April 2001, Perm, Test Round