POJ1745——Divisibility

Divisibility

Description

Consider an arbitrary sequence of integers. One can place + or - operators between integers in the sequence, thus deriving different arithmetical expressions that evaluate to different values. Let us, for example, take the sequence:
17, 5, -21, 15. There are eight possible expressions: 17 + 5 + -21 + 15 = 16

17 + 5 + -21 - 15 = -14

17 + 5 - -21 + 15 = 58

17 + 5 - -21 - 15 = 28

17 - 5 + -21 + 15 = 6

17 - 5 + -21 - 15 = -24

17 - 5 - -21 + 15 = 48

17 - 5 - -21 - 15 = 18

We call the sequence of integers divisible by K if + or - operators can be placed between integers in the sequence in such way that resulting value is divisible by K. In the above example, the sequence is divisible by 7 (17+5+-21-15=-14) but is not divisible
by 5.

You are to write a program that will determine divisibility of sequence of integers.

Input

The first line of the input file contains two integers, N and K (1 <= N <= 10000, 2 <= K <= 100) separated by a space.

The second line contains a sequence of N integers separated by spaces. Each integer is not greater than 10000 by it‘s absolute value.

Output

Write to the output file the word "Divisible" if given sequence of integers is divisible by K or "Not divisible" if it‘s not.

Sample Input

4 7
17 5 -21 15

Sample Output

Divisible

Source

Northeastern Europe 1999

简单dp，一开始想的状态时三维的，而且三重循环导致超时，dp[i][j][0 or 1]表示处理到第i个数时，加上或减去第i个数然后对k求余得到余数为j的可行性，复杂度O(n*m*m)

超时代码：

#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 10010;
const int M = 110;
// const int inf = 0x3f3f3f3f;
bool dp[N][M];
int num[N];

int main()
{
	int n, k;
	while (~scanf("%d%d", &n, &k))
	{
		for (int i = 1; i <= n; ++i)
		{
			scanf("%d", &num[i]);
		}
		memset (dp, 0, sizeof(dp));
		dp[0][0] = 1;
		for (int i = 1; i <= n; ++i)
		{
			for (int j = 0; j < k; ++j)
			{
				for (int l = 0; l < k; ++l)
				{
					if (dp[i - 1][l])
					{
						dp[i][j] = (((l + k) % k + (num[i] + k) % k) % k) == j ? 1 : 0 || dp[i][j];
						dp[i][j] = ((((l + k) % k - (num[i] + k) % k) + k) % k) == j ? 1 : 0 || dp[i][j];
					}
				}
			}
			if (i == n)
			{
				break;
			}
		}
		bool flag = dp[n][0];
		if (flag)
		{
			printf("Divisible\n");
			continue;
		}
		printf("Not divisible\n");
	}
	return 0;
}

后来想到，如果枚举上一次的余数&&可行，则这一次一定存在某个余数是由它转移而来

所以时间复杂度降到O(n*m),可以AC了

#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 10010;
const int M = 110;
// const int inf = 0x3f3f3f3f;
bool dp[N][M];
int num[N];

int main()
{
	int n, k;
	while (~scanf("%d%d", &n, &k))
	{
		for (int i = 1; i <= n; ++i)
		{
			scanf("%d", &num[i]);
		}
		memset (dp, 0, sizeof(dp));
		dp[0][0] = 1;
		for (int i = 1; i <= n; ++i)
		{
			for (int j = 0; j < k; ++j)
			{
				if (dp[i - 1][j])
				{
					dp[i][(j + abs(num[i]) % k) % k] = 1;
					dp[i][(j - abs(num[i]) % k + k) % k] = 1;
				}
			}
		}
		bool flag = dp[n][0];
		if (flag)
		{
			printf("Divisible\n");
			continue;
		}
		printf("Not divisible\n");
	}
	return 0;
}