回文数、整数输出，数字序列最小分割问题

判断一个数字N是不是回文数字

     这里介绍两种方法，一、将数字逆序，N mod 10可以计算出最低位，除以
     10可以去掉最末尾的数字，不断这样操作就可以得到N的一个逆转序列，将
     该序列重新变为一个新的十进制数字，和原来的数字比较可以判断该数字是
     否是回文，N的逆序数字可能会溢出，最好将数字提升计算。
     
     和判断字符串是否回文一样从两边向中间遍历，首先计算M=10^k，该数字是
     小于N的最大数字，N/M可以计算最高位，N%M丢弃最高位，该方法不会产生
     溢出

#include <iostream>
#include <stdlib.h>
#include <limits.h>
#include <assert.h>
int reverse( int r ) {
		int rev = 0;
		while( r != 0 ) {
			rev = rev * 10 + r % 10;
			r /= 10;
		}
		return rev;
}
bool isParlidrom( int n ) {
		return n < 0 ? false : (n == reverse(n));
}
bool isParlidrom2( int n ) {
	if(n < 0)
		return false;
		
	int div = 1;
	while( div <= n / 10 ) 
		div *= 10;
		
	while( n != 0 ) {
		int left = n / div;
		int right = n % 10;
		if(left != right)
			return false;
		n = n % div / 10;
		div /= 100;
	}
	return true;
}
using namespace std;
int main()
{
	assert(isParlidrom(0));
	assert(!isParlidrom(-100));
	assert(isParlidrom(1122332211));
	assert(!isParlidrom(1222222223));
	assert(isParlidrom2(0));
	assert(!isParlidrom2(-100));
	assert(isParlidrom2(1122332211));
	assert(!isParlidrom2(1222222223));
	getchar();
	return 1;
}

putchar()输出数字

     putchar可以输出一位数字，如何使用putchar输出数字N，这个问题和上面
     的问题类似，N mod 10可以输出最低位，然后/10丢掉最低位，不断操作，
     可以得到数字的逆序，可以使用递归，递归的出口是N为0退出，这样就无
     法输出0，将递归条件改为N<10，这样就不存在0的问题。
     第二种方法和上面的数字从左到右遍历类似。代码只给出了第一种方法

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
void printIntHelper( unsigned int i )
{
	if( i < 10 ) {
		putchar( '0' + i );
		return ;
	}
	printIntHelper( i / 10 );
	putchar( '0' + i % 10 );
}

void printInt( int i ) {
	unsigned int k = i;
	if( i < 0 ) {
		putchar( '-' );
		k = abs( i );
	}
	printIntHelper( k );
}

int main() {
	int i = 1 << (sizeof(int) * 8 - 2);
	cout<<i<<endl;
	//cout<<abs(i);
	printInt(i);
	cout<<endl;
	printInt(0);
	getchar();
	return 0;
}

最小数字和分割问题

       给定数字序列，比如100, 200, 300, 400, 500, 600, 700, 800, 900，
       将数字分成K份，每份必须在原序列中是连续的，各份的和分别为
       S1，S2，S3，，，SK，maxS=max{S1, S2, ....SK}, 求maxS的最小值。

       解法一，暴力搜索

       首先从最末尾开始取，第一个人可能取1个，2各或者n数字，第一个人拿
       完后第二个人接着从末尾去，直到最后一个人拿完剩下所有的数字。

#include <iostream>
#include <limits.h>
using namespace std;
int bruteForce( int board[], int size, int k ) {
	int cur = 0, min = INT_MAX, sum = 0;

	if( size == 0 )
		return 0;	
	if( k == 1 ) {
		for( int i = 0; i < size; i++ )
			sum += board[i];
		return sum;
	}

	for( int i = size - 1; i >= 0; i-- ) {
		sum += board[i];
		cur = std::max( sum, bruteForce(board, i, k - 1) );
		if(cur < min)
			min = cur;
	}
	return min;
}

 解法二、动态规划.

      令F[n][k]表示0---n分成k份，所有份之和最大值的最小
      值，则f[n][k] = min{max{f[i][k - 1], a[i+1]+...+a[n]}
      F[i][1]=a[0]+a[1]+a[2]+a[3]+....a[i]。

/*
   f[n][k] = min{max{f[i][k - 1], a[i+1]+...+a[n]} i = 0 to n }
   f[1][k] = a[1];
   f[0][j] = 0 
   f[n][1] = a[1] + a[2]+...+a[n]
 */
#define N	40
int f[N][N];
int sum[N];
void preProcess(int board[], int size)
{
	sum[0] = board[0];
	for(int i = 1; i < size; i++)
		sum[i] = board[i] + sum[i - 1];
}

int DP( int board[], int size, int k ) {
	preProcess( board, size );
	for( int i = 1; i <= k; i++ ) {
		for( int j = 0; j < size; j++ ) {
			if( i == 1 ) {
				f[j][i] = sum[j];
			} else {
			    int min =sum[j], cur = sum[j];
			    for( int p = 0; p <=j; p++ ) {
				   cur = max(f[p][i - 1], sum[j] - sum[p]);
				   if( cur < min )
					  min = cur;	
			    }
			    f[j][i] = min;
		    }
	    }
     }
	return f[size - 1][k];
}

       解法三、贪心算法+二分查找

       将原来的数字序列分成K份，假如给出每份的和的最大值max，通过贪心策略
       判断能否将原来的序列分成K份：从第一份开始，将该份分配的尽量大，
       但是不超过max，该算法如下：

/*the precondition we assum is max is no less than max{board[i]} */
bool couldPartition2(int board[], int size, int k, int max)
{
	int sum = 0;
	int partition = 0;
	for(int i = 0; i < size; i++){
		sum += board[i];
		if(sum > max){
			sum = board[i];
			partition++;
		}
	}
	partition++;
	return partition <= k;
}

      显然，max的最大值为将原来的序列分成一份，最小为将原来的序列和均
      分，然后在max的最大值和最小值之间使用二分查找。

int binSearch( int board[], int size, int k ) {
	preProcess(board, size);

	int left = sum[size - 1] / k;
	int right = sum[size - 1];
	int mid = 0;

	while( left <= right ){
			mid = (left + right) / 2;
			if( couldPartition2(board, size, k, mid) ) {
				right = mid - 1;
			} else {
				left = mid + 1;
			}
	}
	return left;
}

测试代码及结果

int main()
{
	int board[] = {
		100, 200, 300, 400, 500, 600, 700, 800, 900
	};
	int len =  sizeof(board) / sizeof(board[0]);
	cout<<bruteForce(board, len, 3)<<endl;
	cout<<DP(board, len, 3)<<endl;
	cout<<binSearch(board, len, 3);
    getchar();
	return 0;
}