C++博客-Residence for sdfond-随笔分类-Algorithm - Number Theory

又翻出一道老题

sdfond — Mon, 26 Apr 2010 15:34:00 GMT

　　整理东西的时候翻看以前的笔记，看到当初讲座owen讲的一个题，这题当时不会，今天突然来了兴致给做了。
　　给定一个a * b的网格，从左下到右上画一条线穿过的格子数是n。给定一个n问有多少种不同的a和b满足穿过的格子数为n。对应TJU 2880。
　　首先n = a + b - gcd(a, b)。因为对于每个穿过的格子，直线可能会从格子的上侧穿过，也可能从格子的右侧穿过，也可能既穿过上侧也穿过右侧(也就是从右上角穿过)。因为直线总要从左边走到右边，因此恰好有a个格子会被直线穿过右侧(直线是连续的，不会在同一列同时穿过两个格子的右侧)，同理恰好有b个格子会被直线穿过上侧，这样总共就是a + b个。但是这样的话穿过右上角的格子就被重复计算了，这样的格子如果坐标为(x, y)，一定满足这个条件：x : y = a : b，这样ay = bx，显然满足等式的解个数是gcd(a, b)个。这样n的值就被计算出来了。
　　然后设g = gcd(a, b)，a = a' * g, b = b' * g, 那么n = (a' + b' - 1) * g, 其中gcd(a', b') = 1。通过枚举g可以求出满足条件的(a', b')的个数，求和就是结果。接下的问题就是求a' + b' = n'的序对个数。可以认定gcd(a', n') = 1，如果不是这样的话，会有a' = t * A, n' = t * N, 这样的话b' = t(N - A)，这样就和a'、b'互素矛盾。这样只需要求和n'互素的数的个数即可，利用欧拉函数就可以很高效的找到满足条件的序对个数了。

sdfond 2010-04-26 23:34 发表评论

The Proof Of Euclid Algorithm

sdfond — Sat, 24 Apr 2010 13:29:00 GMT

sdfond 2010-04-24 21:29 发表评论

SPOJ 2154 Kruskal

sdfond — Sat, 06 Feb 2010 01:04:00 GMT

【题目大意】
　　猴子和Kruskal玩一个取石子游戏，给定n堆石子，n不大于200，每堆石子的个数大于2小于2 ^ 32，双方轮流取子，每次可以从一堆中取最多k个，当一方取完石子后某堆石子的个数是素数的话那么当前玩家获胜。问猴子是否有必胜策略。

【题目分析】
　　这是一道BT题，中间设置了许多trick。开始对题意没有完全理解，错了很多次，后来找来了数据，才发现了问题。
　　题目中描述的获胜策略是："A player wins if after his move the size of some heap is a prime number."这句话乍一看以为是取完石子后剩下的石子个数是素数的时候就获胜，其实还隐藏着另一种可能：如果多堆石子个数是素数，当前玩家无论怎样取都能获胜，因为在他取完之后，其他堆的石子个数是素数，也满足获胜条件。
　　接下来考虑一般情况。这个题目是限制中间状态的Nim游戏，也就是说，对于一堆个数为n的石子而言，它的SG值取决于小于n的最大素数。注意这里题设又有了一个小trick，题目说明了需要取1到k个，如果当前石子个数本身是素数，当然是没用的，因此是小于n的最大素数。设小于n的最大素数是p(题目中说明了石子个数大于2，因此p一定存在)，那么可以在k步以内到达p的一定是必胜态，而且是直接获胜，需要在输入的时候特判(这一点需要注意，在解决限制中间状态的Nim游戏时一般都需要特判)。然后就是p + k + 1这个状态，因为它可达的状态全是必胜态，因此它是必败态，SG值为0。现在考虑大于p + k + 1的状态，问题出来了。以p + k + 2这个状态为例，因为它可以到达p + 2 ... p + k + 1这些状态，因为p + 2 ... p + k都是直接获胜状态，如何判定他们的SG值呢？如果假设它们的SG值是1，那么p + k + 2这个状态的SG值应该是2。但是思考一下SG值的定义，它是定义在一个DAG上的，所有的状态最后都是可以在有限步内转移到终止态(必败态)。但是p + 1 ... p + k这些状态都转移到了p这个状态上，我们肯定不能认定p状态是终止态，因此仅仅凭借p + 1 ... p + k这些状态是必胜态就简单的把它们的SG值设为1是不恰当的；这些限制状态和以前的题目还不同，这些限制状态都不能转移到终止态上，但是由于题目的要求，它们又都是必胜态，因此把它们的SG值设为无穷大更合适些。
　　仔细思考一下带限制状态的SG游戏，可以发现，它们和一般的SG游戏的区别在于，在分析一般的SG游戏的时候，对于一个状态图而言，转移到终止态的时候并不意味着游戏结束，因为玩家可以通过走其他的状态图来保证是否达到必胜态；但是带限制状态的SG游戏，限制的状态双方都是不敢走的，因为一旦一方走入限制状态，另一方立刻获胜，游戏就终止了。可以认为，只要走入限制态就相当于认输，对于双方玩家而言肯定都不会这样做，因此这些限制状态就成了“死状态”，完全可以忽视这些状态（也就是说不存在到这些状态的转移）。通过上述分析，我们可以认定p + k + 2这个状态的SG值应该是1而不是2。
　　现在这个问题的做法就比较明朗了，对于每堆石子，去掉限制态的讨论后，就变成了在集合{1...k}中选择元素的一个Subtraction Game，它的SG值是模(k + 1)循环的。
　　然后就是求最近素数的问题了，这个没有好办法，只能暴力枚举。对于一个数n，在sqrt(n)到n之间存在素数（感觉应该是，但是不会证），因此最多枚举sqrt(n)次就能找到解。但是每次枚举判素的复杂度还是sqrt(n)，总复杂度还是比较高，我在本地跑数据跑了3秒，交上去超时了（SPOJ的时限10秒，这居然也超时，数据够变态）。想了很久也没有什么新的算法，无奈只能在判素上下点功夫，直接把Miller-Rabin搞出来了，速度提高到了2秒，仍然超时。后来又加了一些常数上的优化，终于过了。

【总结】
　　这个题目做了很长时间，一方面是审题不清，错了几次；另一方面是对于SG的理论理解的不够透彻，想了很久终于想明白了；再有就是优化算法也花了很长时间。不过通过这个题目对于SG理论的理解又进了一步，感觉不错，呵呵。

注：本文作于2009年8月6日 9点27分

sdfond 2010-02-06 09:04 发表评论

UVa 3295 Counting Triangles

sdfond — Thu, 15 Oct 2009 11:54:00 GMT

好久不写了啊，最近打算重新启用这个blog。就先写这个题目吧，满经典的。
【题目大意】
　　m * n的区域内，每个整数坐标都有整点，问以这些整点为端点能够形成多少个三角形。（0 < m, n <= 1000）

【题目分析】
　　这个题目乍一看挺简单的，但是想做对还是要仔细的思考下的。补集转化的思想，求出所有共线的三元组，然后用总数减掉就是答案了，关键就是如何求共线三元组。x坐标相同和y坐标相同的比较好计算，在一条斜线的就不好算了，画个图发现，即使斜率相同的线，经过的格点数可能各不相同。思路当然还是枚举y / x（不同的y / x确定了不同的矩形区域），之后如何有效的计算，我采用的方法可能有些麻烦，有点类容斥的方法。以斜率为a / b为例，(a, b) = g，那么m * n的区域内一定有(m - a + 1) * (n - b + 1)个那么大的矩形，这样的矩形经过的格点数是(g + 1)；然后因为同等斜率小一点的矩形(a - a / g, b - b / g)也是存在的，个数同样可以统计出来，但是有些大矩形包括了，要去掉；因此就采用这种思想，先求出大矩形的个数，然后依次往下减，就可以避免重复计数了。虽然这样复杂度有点高，不过极限数据还是比较快的跑出来了。
　　说的可能不太清楚，具体代码如下：

1 #include <cstdio>
2 #include <iostream>
3 using namespace std;
4 const int N = 1024;
5
6 bool tag[N][N];
7 long long calc(long long n)
8 {
9     if (n <= 2)
10         return 0;
11     return n * (n - 1) * (n - 2) / 6;
12 }
13 int gcd(int a, int b)
14 {
15     return b == 0 ? a : gcd(b, a % b);
16 }
17
18 int main()
19 {
20     int m, n, g, a, b, timer = 1, cnt[N], ta, tb;
21     long long ans;
22
23     while (scanf("%d %d", &m, &n) == 2)
24     {
25         memset(tag, 0, sizeof(tag));
26         if (m == 0 && n == 0)
27             break;
28         ans = calc((m + 1) * (n + 1)) - calc(m + 1) * (n + 1) - calc(n + 1) * (m + 1);
29         for (int i = m; i >= 1; i--)
30             for (int j = n; j >= 1; j--)
31             {
32                 g = gcd(i, j);
33                 a = i / g, b = j / g;
34                 if (tag[a][b])      continue;
35                 memset(cnt, 0, sizeof(cnt));
36                 tag[a][b] = 1;
37                 a = i, b = j;
38                 ta = i / g, tb = j / g;
39                 for (int k = g; k >= 2; k--)
40                 {
41                     cnt[k] += (m - a + 1) * (n - b + 1);
42                     ans -= calc(k + 1) * cnt[k] * 2;
43                     for (int t = 1; t <= k - 2; t++)
44                         cnt[k-t] -= (t + 1) * cnt[k];
45                     a -= ta, b -= tb;
46                 }
47             }
48         cout << "Case " << timer++ << ": " << ans << endl;
49     }
50
51     return 0;
52 }
53

sdfond 2009-10-15 19:54 发表评论

HOJ 1583

sdfond — Fri, 12 Jun 2009 03:15:00 GMT

　　很有意思的题目，给定一个数（长达500000位），问它是不是一个数n的n次幂，如果是，输出n，否则输出-1。还有一个条件是如果不是的话，它只可能有一位写错了，而且数的位数不变。
　　首先考虑如果确定n，当n大于1的时候，n ^ n的位数是不同的(n * logn)，这样根据输入的长度可以确定n。之后就要考虑怎样检测出这个数是不是正确的。因为只有一位可能有变换，那么就是在原数的基础上多了（或少了）一个k * 10 ^ i，其中k = 1...9，i = 0...n。考察这个数的素因子，只可能是2、3、5、7，这样的话如果我取一个模11，显然k * 10 ^ i模11的值一定不为0，这样的话如果有一位发生了变化，它模11的结果和n ^ n模11的结果肯定不同，根据这个方法我就可以在O(L)的复杂度内检测出这个数是否正确了，L是位数。
　　实现的时候有一个很容易出错的地方。因为需要预处理出每个n的n次幂的位数，正常的话n * logn向上取整就是答案，但是n是10的整数幂的时候有些特别，是n * logn + 1，需要单独处理（我是加了一个1e-2再向上取整），因为这个原因错了一次，还有一次是输入的字符串大小开小了。
附题目代码：

#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
const int MOD = 11, N = 100001;

int d[N], m[N];
int power_mod(int a, int b)
{
    int ret = 1, f = a;
    while (b)
    {
        if (b & 1)
            ret = ret * f % MOD;
        f = f * f % MOD;
        b >>= 1;
    }
    return ret;
}
void init()
{
    int tmp;
    for (int i = 2; i < N; i++)
    {
        tmp = (int)(ceil(i * log(i) / log(10.0) + 1e-2) + 1e-1);
        d[i] = tmp;
        m[i] = power_mod(i % MOD, i);
    }
}

int main()
{
    char str[N*5];
    int T, p, len, tmp;

    init();
    scanf("%d", &T);
    while (T--)
    {
        scanf("%s", str);
        len = strlen(str);
        if (len == 1 && str[0] == '1')
        {
            puts("1");
            continue;
        }
        p = lower_bound(d, d + N, len) - d;
        tmp = 0;
        for (int i = 0; i < len; i++)
        {
            tmp = tmp * 10 + (str[i] - '0');
            tmp = tmp % MOD;
        }
        printf("%d\n", tmp == m[p] ? p : -1);
    }

    return 0;
}

sdfond 2009-06-12 11:15 发表评论

PKU 3696

sdfond — Wed, 10 Jun 2009 01:16:00 GMT

　　去年合肥网络赛的题目，今天终于给搞定了。确切的说不是完全独立想出来的，看了网上的一点提示（用欧拉定理），然后想了好几次终于想出来了。
　　题目大意是给定一个L（L不大于2000000000），求最小长度的能整除L的都是8的数，输出长度，如果没有输出0。设长度为n的话，那么这个全为8的数可以表示成8 + 80 + 800 + ...是一个等比数列，变换后得到8 * (10 ^ n - 1) / 9 = k * L。如果L中2的因子数不大于3个，那么可以除掉。之后等式可以写成10 ^ n - 1 = 9 * k * L，也就可以转换成一个模方程：10 ^ n = 1 mod 9L。根据欧拉定理，一定要10和9 * L互素才能有解，这样就可以判定出无解的情况了。之后相当于求一个原根，求出9L的欧拉函数，设其为phi，那么n一定是phi的约数才可以满足条件，枚举phi的约数就可以了。
　　这个题目变态的一个地方在于9L和phi都可能很大，int表示不下，要用long long，这么大的模简单的乘法会溢出，也要写成二分的形式。中间有好几个地方我都用了int，结果导致溢出，超时了2次。总的来说这是个很好的数论题目，以后这种题目应该多练习一些。

sdfond 2009-06-10 09:16 发表评论

PKU 1305

sdfond — Tue, 09 Jun 2009 01:09:00 GMT

　　是个经典问题了，求满足a ^ 2 + b ^ 2 = c ^ 2且a、b、c两两互质的三元组个数，其中a、b、c都小于等于n，同时还要求出n以内不属于三元组（不必互质）的数的个数，其中n <= 1000000。
　　数据范围很大，单纯的n ^ 2的枚举肯定是不行的。我发现互质的三元组不多，想找一个办法求出互质的，然后筛出其他的三元组（乘以倍数），但是仍然想不出怎样很快找到互质的三元组。到网上查了一下，找到了一个很好的网站（http://xserve.math.nctu.edu.tw/people/cpai/carnival/fraction/05.htm）讲解这个问题。
　　首先只需找到互质的a和b就可以了，其余的可以通过乘以一定的倍数得到。首先a和b必须不能都是奇数，否则的话，不妨设a = 2p + 1, b = 2q + 1, c = 2r。带入a ^ 2 + b ^ 2 = c ^ 2有：2 * (r ^ 2 - p ^ 2 - q ^ 2 - p - q) = 1，出现了矛盾。这样必然a和b一奇一偶，设a是偶数。恒等变换一下：（这里是x ^ 2 + y ^ 2 = z ^ 2，x是偶数）

　　令u = (z - y) / 2，v = (z + y) / 2。因为y、z互质，那么u、v互质。如果不互质，有v = ku，变换后得到：z / y = (k + 1) / (k - 1)。因为z和y互质，这样这个等式的解只能是z = k + 1且y = k - 1。这样的话u = 1。可以理解为这也是互质的特殊情况(gcd = 1)。这样(x / 2) ^ 2 = u * v，u和v没有公共的质因数，因此必然u和v都是完全平方数。接下来的事情就比较简单了，令u = m ^ 2，v = n ^ 2，然后利用m和n表示x、y、z有：y = n ^ 2 - m ^ 2，x = 2 * m * n，z = n ^ 2 + m ^ 2。这样题目中数据范围1000000，而枚举m和n的范围最大1000，这个复杂度就可以接受了。枚举的时候不用担心出现重复的互质的x与y，因为这里x一定是偶数，如果x和y已经互质，那么y一定是奇数，解是唯一的。
　　很囧的是这个巧妙的方法居然公元前250年就有大牛想到了（丢番图），实在orz！

sdfond 2009-06-09 09:09 发表评论

完美数问题

sdfond — Thu, 04 Jun 2009 11:57:00 GMT

　　定义一个正整数n的函数F(n)为n的每位数的乘积。一个数是good如果F(n)不为0并且n能整除F(n)，一个数是完美数当且仅当n是good并且n+1也是good。现在问一个长度是k位的数中有多少个完美数，其中k不大于1000000。
　　不得不承认这是一个非常经典的锻炼分析问题能力的题目。设n = a1a2...an，因为F(n)不为0，所以n + 1 = a1a2...(an+1)。根据题目意思，我们可以列出等式：n + 1 = q * (a1 * a2 * ... * (an + 1))，又n = p * (a1 * a2 * ... * an)。令A = a1 * a2 ... * an-1，整理前面的等式可以得到：(q * an + q - an) * A = 1。因为这里面都是整数，显然A = 1，也就是说a1，a2，...，an-1都是1。问题一下子就变得简化了很多，比起之前的单纯枚举可以说是进了一大步。但是如果枚举最后一位判断是不是可行复杂度依然很高，需要进一步讨论。首先an是1、2、5对应的数都是good；an为3的时候，如果是good必须前面n-1个1加和是3的倍数；an为4的时候需要最后两位被4整除才行，14不满足条件；同理an为6的时候也必须前面n-1个1加和是3的倍数；an为8的时候需要后三位的数被8整除，显然也不可能；经过一番讨论，就剩7这个特别的数字了。用一堆1对7试除一下发现一个规律，111111恰好整除7，六个数一循环。这样只需判断(an - 1)是否整除6就可以了。
　　综上所述，对于一个k位的数字，如果k为1，那么结果是8。如果k大于1，结果首先是1，如果k-1能被3整除，结果加2；如果k-1能被6整除，结果再加1。这样O(1)的时间复杂度就出结果了，仔细分析问题后得出的做法真强大啊。

sdfond 2009-06-04 19:57 发表评论

PKU 1811

sdfond — Fri, 03 Apr 2009 12:06:00 GMT

　　大整数的快速质因子分解，用到pollard-rho启发式算法。
　　算法导论上介绍pollard-rho介绍得比较详细，由于小因子的循环节长度很小，通过倍增步长，pollard-rho能够很快的找到一个大整数的一个较小的素因子p，书中说复杂度在O(sqrt(p))内，用的什么概率的分析方法，不懂。实际中pollard-rho的速度还是很快的，当然可能出现死循环。
　　这个题目要利用pollard-rho找到一个数的最小素因子，因此还需要Miller-Rabin测试来辅助。原来写的那个Miller-Rabin很快挂掉了，因为没有用到二次探测，判不出来Carmichael数。如果x ^ 2 = 1 (mod n)，如果n是质数，那么x只能是1和n - 1；二次探测就是利用这个定理来进行检测。
　　POJ的论坛里面更有牛人列出了N多Carmichael数，真不知道他怎么找到的。最初怎么也不知道二次探测加在哪里好，后来参考网上一位大牛的代码，它的方法是计算a ^ b % n的时候，先将b折半到一个奇数b'为止，计算a ^ b'，然后倍增b'，同时进行二次检测，想想觉得很有道理，因为如果x ^ 2 = 1 mod n成立的话，那么(x ^ 2) ^ 2 = 1 mod n也成立。
　　这个题目还有一个trick就是模能达到2 ^ 54，如果这样计算一个数平方的时候，即使long long也会溢出。后来发现可以用快速幂取模的思想弄个"快速积取模"，同样将b表示成二进制的形式，倍增的同时加到结果上就行了。这样每次运算的数范围都在2 ^ 54以内，并且都是加操作，不会溢出了。
　　POJ上还有一个用pollard-rho做的题是PKU 2429，这个比Prime Test还恶，因为这个题目是彻彻底底进行factorization，而且之后还要枚举一下找最优解，总之我的代码非常的长，而且这个题目数据范围2 ^ 63，必须用unsigned long long才能过。我的代码中间出现了一些减操作，都要特殊处理一下。最后还犯了个低级错误，函数返回值写错了，找了好几遍才找出来。

附PKU 1811代码：

PKU 1811

sdfond 2009-04-03 20:06 发表评论

HOJ 1377 - 约数问题

sdfond — Mon, 30 Mar 2009 13:44:00 GMT

题目大意是给定一个数n，问约数个数为n的最小的数k是多少。其中1 <= n <= 10000, k <= 10 ^ 15。
这是一个经典问题了，我一直以为会有经典算法，开始的时候一直往贪心上想，结果owen给出了反例。后来经过吉大牛点拨，因为k <= 10 ^ 15，可以根据这个定界，最差情况k的素因子也不会超过13，这样就可以搜索了！
实现的时候我也犯了几个小错，一个是把10 ^ 15少打了一个0，还有一个剪枝必须加：如果当前结果的约数个数为f，那么如果n % f不为0，则剪掉，因为约数个数是以乘积的关系累加的。

1 #include <cstdio>
2 const int M = 14;
3 const long long max = 1000000000000000LL;
4
5 int p[M] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41}, k;
6 long long ans;
7 void solve(long long v, int factor, int pos)
8 {
9     if (factor >= k)
10     {
11         if (factor == k)    ans  v;
12         return;
13     }
14     if (k % factor) return;
15     if (pos == M)   return;
16     for (int i = 1; i <= 50; i++)
17     {
18         v *= p[pos];
19         if (v > max)    break;
20         solve(v, factor * (i + 1), pos + 1);
21     }
22 }
23
24 int main()
25 {
26     while (scanf("%d", &k) == 1)
27     {
28         ans = max + 1;
29         solve(1, 1, 0);
30         if (ans > max)   printf("-1\n");
31         else             printf("%lld\n", ans);
32     }
33
34     return 0;
35 }
36

sdfond 2009-03-30 21:44 发表评论

N！的最末位非零数

sdfond — Sun, 29 Mar 2009 13:00:00 GMT

　　给定一个数N（N <= 10 ^ 1000），如何快速求得N！的最末位非零数是一个经典的问题。一直以来都被这个问题困扰，今天仔细想了下，终于给想通了，尽管可能有些笨拙，现把想法记录于此。
　　在N很小的情况下，有一个简便的方法：求出1到N之间每个数的2的因子数和5的因子数，记为F(2)和F(5)，显然F(2) >= F(5)。由于在末尾只有2和5相乘才能产生0，如果我们把2和5抛去，那么肯定不会有0，这样就可以一边乘一边模10，防止溢出。剩下的一堆2和5如何处理呢？因为2肯定比5多，因此最末位肯定是偶数（0的阶乘和1的阶乘除外）。而一个偶数不停地乘2，最末位的规律是：2 -> 4 -> 8 -> 6 -> 2 -> ...出现了4位1循环，这样我们先用F(2) - F(5)，使得一部分2和5匹配上，2 * 5 = 10，对末尾不产生影响，剩下的2就模一下4，剩几再乘几次2就可以了。
　　但是这个方法在N非常大的时候肯定就不行了，但是可以利用找循环这个思想继续做。如果算阶乘的时候跳过5的倍数，记G(n)为跳过5的倍数的时候，从1乘到n的最末非零位，也就是把5的倍数当1乘。可以发现：
G(1) = 1, G(2) = 2, G(3) = 6, G(4) = 4, G(5) = 4, G(6) = 4, G(7) = 8, G(8) = 4, G(9) = 6, G(10) = 6, G(11) = 6, G(12) = 2, G(13) = 6...
　　又出现了循环，每10个数循环一次。如何计算G(n)就变的很简单，求出n的最末位，就知道对应的G(n)是多少了，当然需要特判n = 1的情况。由于我们把5的倍数的数都提出来了，提出来的这些数（5、10、15、20、25、30...）每个除以5后又组成了一个阶乘序列！除完5一共提出了n / 5个5，根据之前的分析，每个5都可以拿出一个2和它配对然后把它消去，这样一个5就相当于少一个2，我们就要把原来的数乘以3个2（模四循环）。这样一来5的个数其实也可以模四，模完四之后剩k的话，就可以乘以k个8，就把所有的5消去了。现在总结一下：对一个数n的阶乘，计算它的末尾非零位，先计算G(n)，相当于非5的倍数的数的乘积最末非零位先算好了，然后乘以n / 5 % 4个8，处理了提出的n / 5个5，这样之后还剩下n / 5的阶乘没有算。递归的求解n / 5的阶乘的最末位非零数，再乘上去就得到结果了。
　　这个做法的复杂度就很低了，达到O(log n)，对于10 ^ 1000的数据，利用高精度做就行了。利用这种循环的思想，算排列数P(n, k)的最末非零数也就可以做到了。
附HOJ 1013代码：

1#include <cstdio>
2#include <cstring>
3const int N = 1024;
4
5int hash[10] = {6, 6, 2, 6, 4, 4, 4, 8, 4, 6};
6int one_digit_hash[10] = {1, 1, 2, 6, 4, 2, 2, 4, 2, 8};
7
8int last_digit(char str[N], int st, int to)
9{
10    int i, tmp = 0, ret, num_of_five = 0;
11
12    if (st == to)
13        return one_digit_hash[str[st]-'0'];
14
15    ret = hash[str[to]-'0'];
16    for (i = st; i <= to; i++)
17    {
18        tmp = tmp * 10 + str[i] - '0';
19        str[i] = tmp / 5 + '0';
20        tmp %= 5;
21        num_of_five = (num_of_five * 10 + str[i] - '0') % 4;
22    }
23    if (str[st] == '0')  st++;
24    ret = last_digit(str, st, to) * ret % 10;
25    while (num_of_five--)   ret = ret * 8 % 10;     //mul one 5 equals mul one 8
26
27    return ret;
28}
29
30int main()
31{
32    char str[N];
33
34    while (scanf("%s", str) == 1)
35        printf("%d\n", last_digit(str, 0, strlen(str) - 1));
36
37    return 0;
38}
39

sdfond 2009-03-29 21:00 发表评论

一点思路

sdfond — Sat, 28 Mar 2009 07:02:00 GMT

最近又研究了线性筛素数方法的扩展，的确非常强大。
经典的应用是线性时间筛欧拉函数和求约数个数。我想了一下线性时间筛约数和(积性函数)，也是可行的。
对于一个大于1的数n，可以写成p1 ^ a1 * p2 ^ a2 * ... * pn ^ an，那么n的约数和就是(p1 ^ 0 + p1 ^ 1 + ... p1 ^ a1) * ... * (pn ^ 0 + ... + pn ^ an)，由此就可以有递推关系了：
设f[i]表示i的约数和，e[i]表示i的最小素因子个数，t[i]表示(p1 ^ 0 + .. + p1 ^ a1)，p1是t的最小素因子，a1是p1的幂次，这样对于i * p[j]，如果p[j]不是i的因子，那么根据积性条件，f[i*p[j]] = f[i] * (1 + p[j])，e[i] = 1，t[i] = 1 + p[j]；如果p[j]是i的因子，那么相当于t[i]多了一项p1 ^ (a1 + 1)，首先e[i]++，然后tmp = t[i]，t[i] += p[j] ^ e[i]，f[i*p[j]] = f[i] / tmp * t[i]。这样也就做到了O(1)的时间计算出了f[i*p[j]]同时也计算出了附加信息。

这种方法还可以继续推广，例如可以记录i的最小素因子，这样就可以做到O(log n)时间的素因子分解。

sdfond 2009-03-28 15:02 发表评论

TJU 3027 模线性方程组

sdfond — Sun, 22 Mar 2009 01:51:00 GMT

比较赤裸的模线性方程组模型了，给定的模都是两两互素的，可以用扩展欧几里德和孙子定理来解。第一次写这个，不知道健壮性如何，这个题目数据貌似很弱。。

TJU 3027

sdfond 2009-03-22 09:51 发表评论

HOJ 1356 —— Miller Rabin测试

sdfond — Wed, 18 Mar 2009 13:15:00 GMT

基本的判素都比较慢，对于这个题目的BT数据量(2 ^ 31)，也只能用概率判素模型了。
Miller-Rabin基于费马小定理：如果(a, p) = 1，那么a ^ (p - 1) = 1 mod p。满足这个性质的p叫伪素数，如果一个数是伪素数，那么它有很大可能是素数。通过多次的枚举a，利用快速幂取模判断，就可以知道p是不是素数，Miller-Rabin测试的成功率在3/4。
费马小定理是该定理的特殊形式：如果p是素数，那么对于任意整数a：a ^ p = a mod p。这个定理可以用归纳法证明，证明依据这样一个事实：组合数C(n, k)是一个整数，如果n是素数，那么n和k!、(n - k)!的每一项都互素，可以提出n，也就是C(n, k) / n也是整数，所以n | C(n, k)。
这个题目的代码如下：

#include <cstdio>
#include <stdlib.h>
const int MAX = 4, N = 1000000;

long long PowerMod(long long a, long long b, long long k)
{
    long long ret = 1, f = a;

    while (b)
    {
        if (b & 1)
            ret = ret * f % k;
        f = f * f % k;
        b >>= 1;
    }
    return ret;
}
bool MillerRabin(long long n)
{
    int i;
    long long tmp;

    srand(100);
    for (i = 0; i < MAX; i++)
    {
        tmp = rand() % (n - 1) + 1;
        if (PowerMod(tmp, n - 1, n) != 1)
            break;
    }
    return (i == MAX);
}

int main()
{
    long long n, i, j;
    bool tag[N] = {1, 1, 0};

    for (i = 2; i * i < N; i++)
    {
        if (tag[i]) continue;
        for (j = i; j * i < N; j++)
            tag[j*i] = 1;
    }
    while (scanf("%lld", &n) == 1)
    {
        if (n < N)
            printf("%s\n", tag[n] ? "NO" : "YES");
        else
            printf("%s\n", ((n & 1) == 0) || !MillerRabin(n) ? "NO" : "YES");
    }

    return 0;
}

sdfond 2009-03-18 21:15 发表评论

NKU 1026 ——模线性方程

sdfond — Tue, 17 Mar 2009 12:16:00 GMT

也是很赤裸裸的模型，这里求的是绝对值最小解，还有就是用到高精。我用java不会写传引用，因此只好开了全局变量。

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

public class Main
{
  static public BigInteger x = null, y = null;

  static BigInteger extended_gcd(BigInteger a, BigInteger b)
  {
      BigInteger zero = new BigInteger(new String("0"));
      BigInteger ret, tmp;

      if (b.compareTo(zero) == 0)
      {
          x = new BigInteger(new String("1"));
          y = zero;
          return a;
      }
      ret = extended_gcd(b, a.mod(b));
      tmp = x;
      x = y;
      y = tmp.subtract(a.divide(b).multiply(y));

      return ret;
  }

  static BigInteger modular_linear_equation(BigInteger a, BigInteger b, BigInteger n)
  {
      BigInteger e, e2;
      BigInteger d = extended_gcd(a, n);
      e = b.divide(d).multiply(x).mod(n.divide(d));
      e2 = e.subtract(n.divide(d)).abs();

      if (e.compareTo(e2) < 0)    return e;
      return e2;
  }

  public static void main(String[] args)
  {
      BigInteger a, b, c;
      Scanner in = new Scanner(System.in);

      while (in.hasNext())
      {
          a = in.nextBigInteger();
          b = in.nextBigInteger();
          c = in.nextBigInteger();
          c = c.multiply(new BigInteger(new String("-1")));
          System.out.println(modular_linear_equation(a, c, b));
      }
  }
}

sdfond 2009-03-17 20:16 发表评论

POJ 2115 —— 模线性方程

sdfond — Tue, 17 Mar 2009 10:53:00 GMT

最后化成c * x = b - a mod (2 ^ k)，解这个模线性方程，输出最小正解即可。
写程序的时候有了一个误区，以为如果b - a是负的，把它化成正的话那么输出的时候就可以直接模2 ^ k，不用再考虑是负的情况了。但是忽略了x可能为负的情况，所以WA了很多次。其实根本不需考虑b - a的正负性，最后输出的时候加2 ^ k再模2 ^ k就行了。
还有一个是输出最小解，因为最后的所有解模n / d同余，因此直接模n / d即可。

#include <cstdio>

//ax + by = gcd(a, b)
long long extended_gcd(long long a, long long b, long long &x, long long &y)
{
    long long ret, tmp;
    if (!b)
    {
        x = 1, y = 0;
        return a;
    }
    ret = extended_gcd(b, a % b, x, y);
    tmp = x;
    x = y;
    y = tmp - a / b * y;
    return ret;
}

//ax = b mod n
long long modular_linear_equation(long long a, long long b, long long n)
{
    long long x, y, e;
    long long d = extended_gcd(a, n, x, y);
    if (b % d)  return -1;
    e = b / d * x % n + n;
    return e % (n / d);
}

int main()
{
    long long a, b, c, ans;
    int k;

    while (scanf("%lld %lld %lld %d", &a, &b, &c, &k) == 4)
    {
        if (a == 0 && b == 0 && c == 0 && k == 0)
            break;
        ans = modular_linear_equation(c, b - a, 1LL << k);
        if (ans == -1)
            puts("FOREVER");
        else
            printf("%lld\n", ans);
    }

    return 0;
}

sdfond 2009-03-17 18:53 发表评论

筛法求素数

sdfond — Mon, 16 Mar 2009 13:29:00 GMT

这个是经典的Eraosthenes筛法：

for (int i = 2; i * i < N; i++)
{
    if (tag[i]) continue;
    for (int j = i; i * j < N; j++)
        tag[i*j] = 1;
}
for (int i = 2; i < N; i++)
    if (!tag[i])
        prime[tol++] = i;

但是Eraosthenes筛法的速度并不快，原因在于对于一个合数，这种方法会重复的标记。一种线性筛素数的方法有效的解决了这一点，代码如下：

void get_prime()
{
    int cnt = 0;
    for (int i = 2; i < N; i++)
    {
        if (!tag[i])    p[cnt++] = i;
        for (int j = 0; j < cnt && p[j] * i < N; j++)
        {
            tag[i*p[j]] = 1;
            if (i % p[j] == 0)
                break;
        }
    }
}

可以用均摊分析的方法来分析这个算法的复杂度：由于每个合数都唯一的被它的最小素因子筛一次，而每个合数的最小素因子都是唯一的，因此总复杂度是O(n)。
这种筛法的思想很强悍，有很多利用价值，可以根据这种方法做到线性筛欧拉函数等等，继续研究中。。

sdfond 2009-03-16 21:29 发表评论

整数快速幂取模

sdfond — Sun, 15 Mar 2009 02:58:00 GMT

uva 374 Big Mod

赤裸裸的整数快速幂取模

#include <cstdio>

long long PowerMod(long long a, int b, int k)
{
    long long tmp = a, ret = 1;
    while (b)
    {
        if (b & 1)
            ret = ret * tmp % k;
        tmp = tmp * tmp % k;
        b >>= 1;
    }
    return ret;
}

int main()
{
    long long a;
    int b, k;

    while (scanf("%lld %d %d", &a, &b, &k) == 3)
        printf("%lld\n", PowerMod(a, b, k));

    return 0;
}

sdfond 2009-03-15 10:58 发表评论