Hatena::Grouptopcoder

yuyarinのtopcoder記

TopCoder, Google Code JamPKU JudgeOnlineICPC などのアルゴリズム系プログラミングコンテストの参加や練習の記録を残していきます.

アルゴリズムやテーマで分類した目次はこちら

2010/09/28

SRM 483 Bribes

| 00:55

http://www.topcoder.com/stat?c=problem_solution&rm=305892&rd=14236&pm=11037&cr=22851423

問題

選挙において投票者に最小限の賄賂を渡して勝つようにする.n 人の投票者がいて,それぞれ影響度 influence と抵抗度 resistance が存在する.i 番目の人に賄賂を渡すと,j 番目の人の抵抗度が influence[i]/2^|i-j| だけ減る.全員の抵抗度が 0 以下になれば賄賂は成功する.賄賂が成功する渡し方のうち,賄賂を渡す人数が最小になる人数を返す.できなければ失敗として -1 を返す.

アプローチ

一見すると O(n*2^n) な複数ナップサック問題のように見えるが,影響度の値が 500 以下,つまり 2^9 より小さいので両隣 8 人目まで考慮すればいいことが分かる.これで 2^n の部分が 2^17 の定数で押さえられるので O(n).で解くことができる(定数項はそれなりに大きいので注意).

両隣 8 人を含めた計 17 人への賄賂を 17-bit で表現することができる.DP の問題の分割は投票者の人数で行うことができる.つまり0人,1人,と増やしていく.i 人目の抵抗度を 0 にするには i-8 人目から i+8 人目までの影響度を考慮すればいい.抵抗度を 0 にできるパターンの中から最も賄賂を渡す人数が少ないパターンを記録している. i+1 人目を計算するには i 人目のビットパターンのうち上位 16-bit だけ分かればよいので,配列に保存するのは 16-bit 分で良いことが分かる. n 人目まで繰り返していき,最小の値(人数)を選ぶ.

配列のサイズが大きいので int では allocate できない.short を使う.

ソースコード

#include <cstdio>
#include <string>
#include <vector>
#include <iostream>
#include <sstream>

#include <cmath>

using namespace std;

#define sz(a) int((a).size())
#define For(i,a,b)    for(int i=(a);i<(b);++i)
#define Rep(i,n)      for(int i=0;i<(n);++i)

short dp[51][1<<16];

int minBribes(vector <int> influence, vector <int> resistance)
{
	int n = sz(influence);
	int INF = 100;
	
	Rep(i,n+1) Rep(j,1<<16)
		dp[i][j] = i ? INF : __builtin_popcount(j);
	
	Rep(i,n) Rep(mask,1<<17)
	{
		int sum = 0;
		for(int j=i-8,k=0; j<=i+8; j++,k++)
			if((mask&(1<<k)) && 0<=j&&j<n)
				sum += influence[j]>>abs(j-i);
		if(sum>=resistance[i])
			dp[i+1][mask>>1] = min(
				(int)dp[i+1][mask>>1],
				(int)dp[i][mask%(1<<16)]+mask/(1<<16)
			);
	}
	int r = INF;
	Rep(j,1<<16)
		r = min(r,(int)dp[n][j]);
	
	return r>n ? -1 : r;
}

ttvijfyomttvijfyom2011/02/27 18:44XXnJye <a href="http://idnbvnetymog.com/">idnbvnetymog</a>, [url=http://ftuabcqbiduw.com/]ftuabcqbiduw[/url], [link=http://gwxepxsaficy.com/]gwxepxsaficy[/link], http://judtzquinqwh.com/

2010/05/28

TopCoder Open 2010 Algorithm Qualification Round 3

| 16:31

http://www.topcoder.com/stat?c=problem_statement&pm=10929&rd=14278

問題

横 W 縦 H の芝生をダイアモンドカッターが切っていく.カッターの初期位置と,移動方向のプログラムが与えられたときに,芝生が何分割されているかを答える.

アプローチ

ある位置の芝生の左が切れているかどうかのフラグと上が切れているかどうかのフラグを用意しておき,プログラムを走らせて切っていき,最後に領域を数える.

領域を数えるのは再帰(スタック,深さ優先)だと最悪 10^6 になるのでオーバーフローする.queue を使って幅優先探索を行う.

ソースコード

#include <cstdio>
#include <string>
#include <vector>
#include <iostream>
#include <sstream>
#include <queue>

using namespace std;

typedef pair<int,int> PII;

#define sz(a) int((a).size())
#define pb push_back
#define mp make_pair
#define Forall(i,v)   for(int i=0;i<(int)v.size();++i)
#define For(i,a,b)    for(int i=(a);i<(b);++i)
#define Rep(i,n)      for(int i=0;i<(n);++i)

bool cutu[1024][1024];
bool cutl[1024][1024];
bool glass[1024][1024];

queue<PII> q;

int pieces(int W, int H, int startx, int starty, vector <string> program)
{
	Rep(j,H+1) Rep(i,W+1)
		cutu[j][i] = cutl[j][i] = glass[j][i] = false;
	Rep(i,W+1)
		cutu[0][i] = cutu[H][i] = true;
	Rep(j,H+1)
		cutl[j][0] = cutl[j][W] = true;
	
	int x = startx;
	int y = starty;
	
	Rep(pp,sz(program)) Rep(p,sz(program[pp]))
	{
		switch(program[pp][p])
		{
		case 'U':
			cutl[--y][x] = true;
			break;
		case 'D':
			cutl[y++][x] = true;
			break;
		case 'L':
			cutu[y][--x] = true;
			break;
		case 'R':
			cutu[y][x++] = true;
			break;
		}
	}
	
	int c = 0;
	Rep(j,H) Rep(i,W) if(!glass[j][i])
	{
		c++;
		q.push(mp(i,j));
		while(!q.empty())
		{
			PII co = q.front(); q.pop();
			int x = co.first;
			int y = co.second;
			if(glass[y][x])
				continue;
			glass[y][x] = true;
			if(!cutu[y][x])   q.push(mp(x,y-1));
			if(!cutu[y+1][x]) q.push(mp(x,y+1));
			if(!cutl[y][x])   q.push(mp(x-1,y));
			if(!cutl[y][x+1]) q.push(mp(x+1,y));
		}
	}
	
	return c;
}

DiegoDiego2012/07/10 00:56The pucrahses I make are entirely based on these articles.

rcomsiercomsie2012/07/10 15:55WkGRgf <a href="http://ndjqpxpaabuy.com/">ndjqpxpaabuy</a>

lurhlpgihxdlurhlpgihxd2012/07/10 21:512sAKJD , [url=http://wyqyxabtrpox.com/]wyqyxabtrpox[/url], [link=http://fetlavsdhbsq.com/]fetlavsdhbsq[/link], http://frjyegfwmtje.com/

sxyqsmsxyqsm2012/07/12 12:11UCCj2u <a href="http://srlypizeryby.com/">srlypizeryby</a>

2010/05/27

Google Code Jam 2010 Round 1A C. Number Game

| 18:46

問題

黒板に A, B 2つの数字がかかれていて,2人のプレイヤーこの数字を使ってゲームを行う. プレイヤーは交互に数字 A を A-k*B に置き換えるか,数字 B を B-k*A に置き換える操作をする. k は正数である.これを交互に行っていき,数字を 0 以下にしてしまった方が負けである.このゲームの初期値に対する先攻の必勝パターンの数を範囲 A∈[A1,A2] B∈[B1,B2] において求める.

アプローチ(再帰)

とりあえず再帰を使って単純に実装してみる.

using namespace std;
typedef long long ll;

#define For(i,a,b)    for(int i=(a);i<(b);++i)
#define Rep(i,n)      for(int i=0;i<(n);++i)

// 必ず a>=b
// p==true: player が先攻
// 先攻のプレイヤーが必勝の場合は true を返す
bool rec(int a, int b, bool p)
{
	if(b<=0) return !p;
	For(k,1,(a-1)/b+1)
		if(rec(max(a-k*b,b),min(a-k*b,b),!p)==p) return p;
	return !p;
}

int main(void)
{
	int T;
	cin >> T;
	
	Rep(t,T)
	{
		int A1, A2, B1, B2;
		cin >> A1 >> A2 >> B1 >> B2;
		ll r = 0;
		For(a,A1,A2+1) For(b,B1,B2+1)
			if(rec(max(a,b),min(a,b),true)) r++;
		cout << "Case #" << t+1 << ": " << r << endl;
	}
}

sample は通るけど最大のケース,たとえば (A, B) = (1000000,1) だとスタックが足りなくなって落ちる*1ことや,そもそも計算が終わらないだろうことが容易に想像がつく.また,1,000,000 x 1,000,000 の配列を用意しておくのもメモリサイズの制約上厳しい.VSIZE 3728GB って...

http://www.yuyarin.net/screenshot/20100527152740.png

なので数学的に解を出す方向で考えてみる.

アプローチ(数学)

ひとまず 50x50 ぐらいで出力してみると,傾向があるのがわかる.

↓A B→
 *************************************************
*  ***********************************************
*   **********************************************
**    ********************************************
***     ******************************************
***      *****************************************
****       ***************************************
****        **************************************
*****         ************************************
******          **********************************
******           *********************************
*******            *******************************
********             *****************************
********              ****************************
*********               **************************
*********                *************************
**********                 ***********************
***********                  *********************
***********                   ********************
************                    ******************
************                     *****************
*************                      ***************
**************                       *************
**************                        ************
***************                         **********
****************                          ********
****************                           *******
*****************                            *****
*****************                             ****
******************                              **
*******************                               
*******************                               
********************                              
*********************                             
*********************                             
**********************                            
**********************                            
***********************                           
************************                          
************************                          
*************************                         
*************************                         
**************************                        
***************************                       
***************************                       
****************************                      
*****************************                     
*****************************                     
******************************                    
******************************                    

A > αB の場合と B > αA の場合に必勝パターンであることが分かる.このαを求める.

A, B は対称性があるので A > B の場合のみを考えれば良い(A==B の場合は先手が必ず負ける).

まず A >= 2B の場合に必勝パターンであることは簡単にわかる.が,よく見ると傾きは 2 より若干小さい.(11,6) -> A:(5,6) -> B:(5,1) -> A(1,1) -> B:(1,0) と A < 2B でも A が必ず勝てる組が存在する.A >= 2B の場合に必勝パターンであるということは先に選択肢を持った方が必ず勝つということである.

なのでどちらも選択肢が 2 つ以上持てないギリギリのパターンを考えると,(1,1) <- (2,1) <- (3,2) <- (5,3) <- (8,5) <- ... という組の列になる.この列はフィボナッチ数列になっている.このとき A と B の比はフィボナッチ数列の隣接項の比,黄金比 Φ=(sqrt(5.0)+1)/2 ≒ 1.6 である.よって A > ΦB であれば必勝パターンであることがわかる.

B をある値 b に固定したときに A > Φb であればよい.[A1, A2] でこのようになる A の個数は max(0,A2-max(A1,Φb)+1) である.これを b∈[B1, B2] の範囲で調べた後,A, B を反対にした場合の数を調べれば良い.

ソースコード

答えとなる数値は最大で 1M x 1M であるから int だとオーバーフローするので long long を使用する.

#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#include <cmath>

typedef long long ll;

using namespace std;

#define For(i,a,b)    for(int i=(a);i<(b);++i)
#define Rep(i,n)      for(int i=0;i<(n);++i)

double golden = (sqrt(5.0)+1)/2;

ll solve(int A1, int A2, int B1, int B2)
{
	ll r = 0;
	For(b,B1,B2+1)
		r += max(0,A2-max(A1,int(b*golden)+1)+1);
	return r;
}

int main(int argc, char* argv[])
{
	int T;
	cin >> T;
	
	Rep(t,T)
	{
		int A1, A2, B1, B2;
		cin >> A1 >> A2 >> B1 >> B2;
		ll r = solve(A1, A2, B1, B2) + solve(B1, B2, A1, A2);
		cout << "Case #" << t+1 << ": " << r << endl;
	}
	
	return 0;
}

*1Mac OS X ではデフォルトで 8192 KB なので 10 万回ぐらいめの再帰で溢れてしまう.

VadimVadim2012/07/09 23:30Articles like this are an example of quick, hlepful answers.

qjbrhhqjbrhh2012/07/10 15:49kSuNdQ <a href="http://mdjoejftmbvz.com/">mdjoejftmbvz</a>

pqzkpfjtrpqzkpfjtr2012/07/10 21:46qQr9EH , [url=http://fhvkqwxahzhs.com/]fhvkqwxahzhs[/url], [link=http://mdchxyyvtvey.com/]mdchxyyvtvey[/link], http://rqniilnhuwie.com/

oidakxcccinoidakxcccin2012/07/12 12:07Jpayqp <a href="http://jyiazemeadxh.com/">jyiazemeadxh</a>

whmpyvpwhmpyvp2012/07/12 17:36VAQd8L , [url=http://gqopwfgotuey.com/]gqopwfgotuey[/url], [link=http://lfdyxzapnxeq.com/]lfdyxzapnxeq[/link], http://kqvfxprmucse.com/

2010/05/24

Google Code Jam 2010 Round 1C C. Making Chess Boards

| 11:40

「多分解けると思う」とか書いたので解いてみた.1時間かからなかったので B で試行錯誤せずにこっちを先に解けばよかったと思う.

問題

各マスが白か黒かで塗られた板が与えられるのでそこからチェスボード(市松模様の正方形)を切り出していく問題.切り取れるサイズが大きい順,次に上に位置する順,次に左に位置する順,で切り取っていき,切り取ることができたチェスボードのサイズと個数を求める.

結果

単純な実装をしたけど large input に対しても1秒以内で答えが出た.

アプローチ

列方向を(右向き正)を x, i 軸とする.行方向(下向き正)を y, j 軸とする.

とりあえず hex で渡されたデータを bool に変換する(*1).

以下,したのようなデータを例にする.

 01234567→ x, i
0□■■□■□■■
1■□■■□■■■
2□■■□■□□□
3□■■■□■□■
4■□□□■□■□
5■□■■□■□■
6□■■□■□■□
7■■□□■□□■
↓ y, j

答えは

4 1 (3,3)
3 1 (3,0)
2 3 (0,0), (0,3), (0,5)
1 27

まずあるマスが x, y 方向に,市松模様がこれまでいくつつづいているのかを調べる(*2).配列を mx, my とすると,こんなふうな結果になる.

mx[8][8]
[1][2][1][2][3][4][5][1]
[1][2][3][1][2][3][1][1]
[1][2][1][2][3][4][1][1]
[1][2][1][1][2][3][4][5]
[1][2][1][1][2][3][4][5]
[1][2][3][1][2][3][4][5]
[1][2][1][2][3][4][5][6]
[1][1][2][1][2][3][1][2]

my[8][8]
[1][1][1][1][1][1][1][1]
[2][2][1][2][2][2][1][1]
[3][3][1][3][3][3][2][2]
[1][1][1][4][4][4][1][3]
[2][2][2][5][5][5][2][4]
[1][1][3][6][6][6][3][5]
[2][2][1][7][7][7][4][6]
[3][1][2][1][1][1][5][7]

大きい順に求めるので最大のサイズ,つまりボードの短い辺のサイズから見て行く(*3).この例の場合 8 だが,切り取れるチェスボードのサイズは 4 なので s=4 とする.

あるマス (i, j) に着目したときにそれがサイズ s のチェスボードになっているか判定する.上・左から切り取るので左上から見ていくようにループを回す.(i, j) = (3, 3) を例とする.

(i, j) から y 方向にサイズ s だけ市松模様になっている条件は

my[j+s-1][i] - my[j][i] == s-1

である.市松模様が続いていれば my の値は 1 ずつ増えていくので最初のマス (i,j) と最後のマス (i, j+s-1) の my の差が s-1 になっていなければならない.逆に s-1 より小さい場合は途中で市松模様が切れていることがわかる(*4).

my[8][8]
 1  1  1  1  1  1  1  1 
 2  2  1  2  2  2  1  1 
 3  3  1  3  3  3  2  2 
 1  1  1 (4) 4  4  1  3 
 2  2  2  5  5  5  2  4 
 1  1  3  6  6  6  3  5 
 2  2  1 [7] 7  7  4  6 
 3  1  2  1  1  1  5  7

この例では (3, 3) は (4),(3, 3+s-1) = (3, 6) は [7] であるので条件を満たす.(3, 7) は 1 なので市松模様が切れていることが分かる.なので (3, 3) からサイズ 5 のチェスボードは切り取れない.

次に [j,j+s-1] のそれぞれの行について x 方向に市松模様が続いているか見て行く(*5).すべての行について同様の条件が成り立てば,チェスボードになっていると判定できる(*6).

mx[8][8]
 1  2  1  2  3  4  5  1 
 1  2  3  1  2  3  1  1 
 1  2  1  2  3  4  1  1 
 1  2  1 (1) 2  3 [4] 5 : j   = 3
 1  2  1 (1) 2  3 [4] 5 : j+1 = 4
 1  2  3 (1) 2  3 [4] 5 : j+2 = 5
 1  2  1 (2) 3  4 [5] 6 : j+s-1 = 6 (s=4)
 1  1  2  1  2  3  1  2

例では (3, j)→(6,j) (j∈[3,6]) のそれぞれについて差が s-1 = 3 になっているので市松模様になっている.

[i,i+s-1] のそれぞれの列について y 方向に市松模様が続いているのか調べる必要はない.これで十分である.

切り取った部分は 0 を代入して切り取ったことを示しておく(*7).

mx[8][8]
 1  2  1  2  3  4  5  1 
 1  2  3  1  2  3  1  1 
 1  2  1  2  3  4  1  1 
 1  2  1  0  0  0  0  5 
 1  2  1  0  0  0  0  5 
 1  2  3  0  0  0  0  5 
 1  2  1  0  0  0  0  6 
 1  1  2  1  2  3  1  2

これの操作をサイズについて大きい順で,上から,左から,行っていけば良い.

ソースコード

  • 初期化が冗長だったので冗長部分を削除
    • mx[], my[] には初めから 1 を代入すればいい
    • b[][] は false で初期化しなくてもいい
  • 切り取った箇所に代入する値を -1 から 0 に変更
  • 高速化のためサイズ 1 のボードの数を数えるのをやめて,計算する方法に変更
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

typedef vector<int> VI;
typedef vector<string> VS;

#define Forall(i,v)   for(int i=0;i<(int)v.size();++i)
#define For(i,a,b)    for(int i=(a);i<(b);++i)
#define ForD(i,a,b)   for(int i=(a);i>(b);--i)
#define Rep(i,n)      for(int i=0;i<(n);++i)

#define sz(a) int((a).size())

bool b[512][512]; // 各マスの色, false なら白
int mx[512][512]; // x 方向に何マス市松が続いているか
int my[512][512]; // y 方向に何マス市松が続いているか
// mx, my は切り取られたら 0 を代入

int solve(int M, int N, VS &v)
{
	// 初期化
	Rep(j,512) Rep(i,512)
		mx[j][i] = my[j][i] = 1;
	
	// 入力が Hex で渡されるので 2 値に変換 (*1)
	Rep(j,M) Rep(i,N/4) ForD(k,3,-1)
	{
		char c = (v[j][i]>='A')?v[j][i]-'A'+10:v[j][i]-'0';
		b[j][i*4+3-k] = (((c>>k)&1u)==1u);
	}
	
	// x 方向に市松模様が続く数を数える (*2)
	Rep(j,M) For(i,1,N) if(b[j][i]!=b[j][i-1])
		mx[j][i] = mx[j][i-1]+1;
	
	// y 方向に市松模様が続く数を数える
	Rep(i,N) For(j,1,M) if(b[j][i]!=b[j-1][i])
		my[j][i] = my[j-1][i]+1;
	
	int ms = min(N,M); // 切り出せる最大のサイズ
	VI scv(ms);        // サイズごとの切り出した個数
	
	int cut = 0;
	
	// サイズの大きい順に (*3)
	ForD(s,ms,0)
	{
		scv[ms-s] = 0;
		// あるマス (i,j) に着目
		Rep(j,M) Rep(i,N)
		{
			// 既に切り取られた
			if(mx[j][i]<0) continue;

			// 範囲オーバー
			if(i+s-1>=N) continue;
			if(j+s-1>=M) continue;

			// y 方向に市松模様が続かない (*4)
			if(my[j+s-1][i]-my[j][i]<s-1) continue;

			// 各行について x 方向に市松模様が続くか (*5)
			bool f = true;
			For(y,0,s) if(mx[j+y][i+s-1]-mx[j+y][i]!=s-1)
			{
				f = false;
				break;
			}
			// チェスボードになった (*6)
			if(f)
			{
				scv[ms-s]++;
				cut += s*s;
				// 切り取る (*7)
				For(y,j,j+s) For(x,i,i+s)
					mx[y][x] = my[y][x] = -1;
			}
		}
	}

	scv[0] = M*N - cut;
	
	// 数えて出力
	int c = 0;
	Rep(i,ms) if(scv[i]>0)
		c++;
	cout << c << endl;
	
	ForD(s,ms,0) if(scv[ms-s]>0)
		cout << s << " "<<scv[ms-s]<<endl;
	
	return 0;
}

int main(int argc, char* argv[])
{
	int num_of_test_cases;
	cin >> num_of_test_cases;
	
	Rep(test_case,num_of_test_cases)
	{
		int M, N;
		cin >> M >> N;
		VS v(M);
		Rep(i,M) cin >> v[i];
		cout << "Case #" << test_case+1 << ": ";
		solve(M, N, v);
	}
	
	return 0;
}

忍者最終号忍者最終号2010/05/24 14:291を数えないようにした方がもっと早くなりそうだ.

yuyarinyuyarin2010/05/27 10:16あ,本当ですね.
そのようにしてみました.

2010/05/12

TopCoder Open 2010 Algorithm Qualification Round 2 FuzzyLife

| 23:48

http://www.topcoder.com/stat?c=problem_statement&pm=10911&rd=14277

500 pt. 問題.

周りのセルも数えることを忘れていたことで時間を取ってしまい,最後 30 秒で Sample を Passed して commit.Challenging Phase で撃墜される.最大のケースで TLE してしまっていたようだ.

再帰によって n 個ある ? のセルを 1 つずつ固定して生存セルが一番多くなるものを選ぶ方法を取っていたのだけど,この方法の計算量は O(2^n) で,最大のケースだと n=272 が可能となり,このスケールになると TLE してしまう.

No cell will have more than one neighboring cell of type '?'

というのがヒントで,これはつまり,ある ? のセルを確定させる時に影響されるセルは他の ? のセルの影響を受けないということである.つまり1つずつ確定(固定ではない)させて行くことができる.これなら O(n) で処理できる.

具体的には ? がでてきたら,その周り 9 マスだけを計算して,多い方を選んで確定していけば十分である.


#include <cstdio>
#include <string>
#include <vector>
#include <iostream>
#include <sstream>

using namespace std;

typedef vector<string> VS;

#define sz(a) int((a).size())

int n;
int m;

class FuzzyLife
{
public:

// grid の特定の範囲だけ計算
int calcRange(VS &g, int mini, int maxi, int minj, int maxj)
{
	int tc = 0;
	for(int i=mini; i<=maxi; i++)
	{
		for(int j=minj; j<=maxj; j++)
		{
			int c = 0;
			if(i>0)
			{
				c += g[i-1][j]-'0';
				if(j>0)
					c += g[i-1][j-1]-'0';
				if(j<m-1)
					c += g[i-1][j+1]-'0';
			}
			if(i<n-1)
			{
				c += g[i+1][j]-'0';
				if(j>0)
					c += g[i+1][j-1]-'0';
				if(j<m-1)
					c += g[i+1][j+1]-'0';
			}
			if(j>0)
				c += g[i][j-1]-'0';
			if(j<m-1)
				c += g[i][j+1]-'0';
			if(g[i][j]=='1')
				if(c==2||c==3) tc++;
			else
				if(c==3) tc++;
		}
	}
	return tc;
}

int survivingCells(vector <string> grid)
{
	n = sz(grid);
	m = (int)grid[0].length();
	
	// 周りに 0 を 1 周分追加
	VS g;
	string s(m+2, '0');
	g.push_back(s);
	for(int i=0; i<n; i++)
		g.push_back("0"+grid[i]+"0");
	g.push_back(s);
	
	n += 2;
	m += 2;
	
	for(int i=0; i<n; i++)
	{
		for(int j=0; j<m; j++)
		{
			if(g[i][j]=='?')
			{
				// ? のセルを固定して,周囲 9 セルだけを計算
				g[i][j] = '0';
				int r0 = calcRange(g, i-1, i+1, j-1, j+1);
				g[i][j] = '1';
				int r1 = calcRange(g, i-1, i+1, j-1, j+1);
				// 確定する
				g[i][j] = (r0>r1) ? '0':'1';
			}
		}
	}
	
	// 全体を計算する
	return calcRange(g, 0, n-1, 0, m-1);
}

AgustinaAgustina2012/07/10 05:30Yo, good loiokn out! Gonna make it work now.

dvmpfhnxpodvmpfhnxpo2012/07/10 16:19M992tq <a href="http://abuptwpwcqym.com/">abuptwpwcqym</a>

pptauxpptaux2012/07/11 20:46FCqabg , [url=http://fihpbpjoyarc.com/]fihpbpjoyarc[/url], [link=http://ciuzxzgiuyqo.com/]ciuzxzgiuyqo[/link], http://lvgsivtbvmij.com/

ktxodmtktxodmt2012/07/12 12:32jofRQ4 <a href="http://kizscxqiqaki.com/">kizscxqiqaki</a>

fncfmwxjlrfncfmwxjlr2012/07/12 18:05oX6byq , [url=http://cgudxnkygdfi.com/]cgudxnkygdfi[/url], [link=http://iuikvqdlnsqu.com/]iuikvqdlnsqu[/link], http://ebjctraukepx.com/