C++博客-英雄哪里出来-随笔分类-数学[更新中...]

ZJU 3108 Last Digit

英雄哪里出来 — Fri, 15 Apr 2011 06:19:00 GMT

摘要: 题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=2984 /**//*题意：给出一个长度为N(N <= 1000000)的串，要求求出所有串的不重复排列的方案。输出方案数的最后一个非零位。题解：组... 阅读全文

英雄哪里出来 2011-04-15 14:19 发表评论

PKU 3489 Knapsack I

英雄哪里出来 — Fri, 15 Apr 2011 04:03:00 GMT

题目链接：http://poj.org/problem?id=3489

/*
题意：
    给定n( n <= 1000 )个大小为Vi的物品，每个物品都可以拆分成k次，拆分好的
物品可以继续拆分，Vi是整数，但是拆分好的物品的大小可以是任意实数，例如本来
Vi为7的物品拆分成5份，那么每份大小就是1.4，问最后能不能通过拆分和组合组出
大小为x的物品（每个物品的供应量是无穷多的）。

题解：
    数学推导

思路：
    问题求得就是以下方程有没有整数解：
    x1*V1/(k^y1) + x2*V2/(k^y2) +  +    xn*Vn/(k^yn) = x
其中x1，y1是未知量。首先要明确的一点是，一个物品可以拆分的无限小，也就是
k^yi可以很大很大，因为当k^yi取得越大时，我们总可以找到k^yi个这类物品把它
还原成原来的大小，所以不影响解题；相反，如果取得比较小的话可能找不到可行
解，因为还没有达到要拆分的次数，然后我们这样考虑，令G = gcd(V1, V2 )
，并且Ti = Vi / G。那么原方程就可以表示成如下形式：
    G * ( x1*T1/(k^y1) + x2*T2/(k^y2) +  +    xn*Tn/(k^yn) ) = x
    然后令M = k^j，你可以假设这个M足够大。再将上面的方程变形：
    S = x1*T1*(k^(j-y1)) + x2*T2*(k^(j-y2)) +  +    xn*Tn/(k^(j-yn));
    G / M * S = x
    接下啦，如果在G中的素因子同时存在于k中，那么我们把这些素因子全部剔除
，这一步其实就是求G和M的最大公约数，这就是为什么M要取足够大的原因。方程
转变成：
    G' = G / gcd(G, M);
    M' = M / gcd(G, M);
    G' / M' * S = x;
    然后我们将等式两边都乘上M'，可以得到：
    G'* S = x * M';
    这四个数都是整数，G'和M'互质，所以G'必然要整除x，否则方程无解。那么
接下来就是要看，如果整除的话是否一定有解。
    令x' = x / G'; 那么有S = x' * M';
    首先考虑n = 1的情况，如果n = 1，那么x1*(k^(j-y1)) = x' * M';我们只要
取x1 = x' * M'，y1 = j 就可以了。
    然后是n > 1的情况，我们取任意两种物品，其他物品假设都不取，如果这样都
能组合出来，那么结论就显然了。来看下面的方程：
    A = x1*T1*(k^(j-y1));
    B = x2*T2*(k^(j-y2));
    A + B = x' * M';
    于是问题就转变成了线性同余方程是否有整数解的问题了。
    不妨假设y1 < y2，那么GG = gcd(A, B) = k^(j-y2);因为y1和y2的各自取值不
影响最后结果（因为可用很多个x2来补充），我们可以大胆的将y2取值为j。于是GG
就等于1了。这样方程就必然有解了。
    结论得证。
*/

#include <iostream>
#include <vector>
#include <vector>
using namespace std;

#define maxn 65537

bool f[maxn];
int prime[maxn], size;

int gcd(int a, int b) {
    return b==0 ? a : gcd(b, a%b);
}

void Divide(vector<int>& ans, int v) {
    ans.clear();
    if(v == 1)
        return ;
    int i;
    for(i = 0; i < size; i++) {
        if(v % prime[i] == 0) {
            while(v % prime[i] == 0)
                v /= prime[i];
            ans.push_back(prime[i]);
            if(v == 1)
                return ;
        }
    }
    ans.push_back(v);
}

int n, x, k;

int main() {
    int i, j;
    for(i = 2; i < maxn; i++) {
        if(!f[i]) {
            prime[size++] = i;
            for(j = i+i; j < maxn; j += i) {
                f[j] = 1;
            }
        }
    }

    while(scanf("%d %d %d", &n, &x, &k) != EOF) {
        int G = 0;
        for(i = 0; i < n; i++) {
            int val;
            scanf("%d", &val);
            if(i)
                G = gcd(G, val);
            else
                G = val;
        }
        vector<int> vecG;
        vector<int> vecK;
        Divide(vecG, G);
        Divide(vecK, k);

        bool flag = false;
        for(i = 0; i < vecG.size(); i++) {
            for(j = 0; j < vecK.size(); j++) {
                if(vecG[i] == vecK[j])
                    break;
            }
            if(j == vecK.size()) {
                while(G % vecG[i] == 0) {
                    G /= vecG[i];
                    if(x % vecG[i] == 0)
                        x /= vecG[i];
                    else {
                        flag = true;
                        break;
                    }
                }
                if(flag)
                    break;
            }
        }
        printf("%s\n", flag ? "No" : "Yes");

    }
    return 0;
}

英雄哪里出来 2011-04-15 12:03 发表评论

HDU 3758 Factorial Simplification

英雄哪里出来 — Fri, 15 Apr 2011 01:11:00 GMT

摘要: 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3758 /**//*题意：给定N个和M个不大于10000的数(N,M <= 1000)，N个数各自的阶乘的乘积除上M个数各自阶乘的乘积是一个很大的数，现在要求将这个数表示成如下形式： ... 阅读全文

英雄哪里出来 2011-04-15 09:11 发表评论

HDU 3756 Dome of Circus

英雄哪里出来 — Tue, 12 Apr 2011 14:58:00 GMT

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3756

/*
题意：
    在一个三维空间中，给定一些点，这些点的z坐标都是大于0的。要求求
出一个圆锥（底面是圆形），使得这个圆锥的底面在z = 0的平面上，它能够
包含所有给定的点并且圆锥的体积要求最小。

题解：
    数学推导 + 三分

思路：
    这是一个很有意思的题，虽然是三维的，但是可以很容易的转化到二维去
。来看X-Z这个平面，我们将所有的点进行圆周映射，然后将所有的点都投影到
X-Z平面的的第一象限去，然后问题就转化成了在X-Z平面上找到一条斜率为负
的直线L，L和X正方向、Z正方向围成的三角形包含所有点，如果假设L和X轴的
交点为R，和Z轴焦点为H，要求pi*H*R^2的值最小。
    然后我们来看看H和R之间有什么千丝万缕的关系。首先L这条线必定和某一
个给定的点擦边，也就是经过那个点，我们假设它经过P(a, b)，并且L的斜率
为K(K < 0)，那么L的方程就可以表示为 L:  y = K * (x - a) + b，则H和R就
可以利用这个方程表示出来：
H = -a * K + b;
R = -b / K + a;
那么所求的圆锥的体积就是：
V = pi*H*R^2 = pi * (-a * K + b) * (-b / K + a) ^ 2
容易得到V(K)这个函数的导数：
V'(K) = - pi * (aK^2 + 2bK) * (aK - b)^2 / K^2
影响这个导数的正负性的唯一条件是 -(aK^2 + 2bK)
当-2b/a < K < 0时V'(K)大于零，也就是V的值是随着K递增的。
当K < -2b/a时V'(K)小于零，也就是V的值是随着K递减的。
于是可以得出一个结论，当K = -2b/a 时V取得最小值。
于是我们知道了V的单峰性，然后就可以通过枚举半径R，因为R对于V具有单谷
性，所以枚举R的时候可以采用三分。每次通过三分R找到最小的H，这个过程可
以通过枚举每个点，找到最大的极角alpha，R*tan(alpha)就是H了。
    这里需要注意的就是精度问题了。
*/

#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;

#define eps 1e-6
const double pi = acos(-1.0);

struct Point {
    double x, y, z;
    double v, h;

    void SCANF() {
        scanf("%lf %lf %lf", &x, &y, &z);
        v = z;
        h = sqrt(x*x + y*y);
    }
}pt[ 10001 ];

int n;
double MaxH, MaxV;

double Calc(double R) {
    int i;
    double Max = 0;
    int idx = 0;
    for(i = 0; i < n; i++) {
        double nv = pt[i].v / (R - pt[i].h);
        if(nv > Max) {
            Max = nv;
            idx = i;
        }
    }
    return Max * R;
}

int main() {
    int t;
    int i;

    scanf("%d", &t);
    while(t--) {
        scanf("%d", &n);
        MaxH = MaxV = 0;
        for(i = 0; i < n; i++) {
            pt[i].SCANF();
            if(pt[i].h > MaxH)
                MaxH = pt[i].h;
            if(pt[i].v > MaxV)
                MaxV = pt[i].v;
        }

        double l = MaxH + eps, r = 1e6;
        double ml, mr;

        while(l + 1e-6 < r) {
            ml = (2 * l + r) / 3;
            mr = (l + 2 * r) / 3;

            double lans = Calc(ml) * ml * ml;
            double rans = Calc(mr) * mr * mr;

            if( lans > rans ) {
                l = ml + 1e-5;
            }else
                r = mr - 1e-5;
        }
        double ans = (l + r) / 2;
        printf("%.3lf %.3lf\n", Calc(ans), ans);
    }
    return 0;
}

英雄哪里出来 2011-04-12 22:58 发表评论

HDU 1066 Last non-zero Digit in N!

英雄哪里出来 — Mon, 11 Apr 2011 04:11:00 GMT

摘要: 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1066 /**//*题意：给定一个数N(N <= 10^200)，求出N的阶乘的最后一位非零数字。题解：找规律 + 大数模拟思路： &nb... 阅读全文

英雄哪里出来 2011-04-11 12:11 发表评论

PKU 1186 方程的解数

英雄哪里出来 — Sat, 09 Apr 2011 15:55:00 GMT

摘要: 题目链接：http://poj.org/problem?id=1186 /**//*题意：已知一个n元高次方程：其中：x1, x2,,xn是未知数，k1,k2,,kn是系数，p1,p2,pn是指数。且方程中的所有数均为整数。假设未知数1 <= xi <= M,&n... 阅读全文

英雄哪里出来 2011-04-09 23:55 发表评论

PKU 2720 Last Digits

英雄哪里出来 — Thu, 07 Apr 2011 12:02:00 GMT

摘要: 题目链接：http://poj.org/problem?id=2720 /**//*题意：给定三个整数 b, n, 和 i, 定义函数 f(x) = b^f(x-1) 如果 x > 0, 并且 f(0)=... 阅读全文

英雄哪里出来 2011-04-07 20:02 发表评论

PKU 3492 Knapsack II

英雄哪里出来 — Tue, 05 Apr 2011 11:01:00 GMT

题目链接：http://poj.org/problem?id=3492

/*
题意：
    给出n(n <= 500)个数ai(ai <= 5000)，求他们的最大不能组合数。

解法：
数论 + 最短路

思路：
    经典的组合问题Change Making Problem，这个题目有一个限制就是给
定的数小于等于5000，题目的意思很清楚，就是求一个数S，使得它不能被
任何ai的倍数所组合出来，并且它的值最大。
    那么如果这n个数的gcd不为1，必然找不到这样的S，因为如果S不能被
它们的gcd整除，永远不可能组合出来，这样S就可以很大，自然也就没有最
大的S了。
    现在讨论所有ai的gcd为1的情况。对于任意的整数A，如果A能被以上的
ai组合出来，那么 B = A + k*a0 必然能被组合（只要加上k个a0即可）。于
是我们可以吧所有整数划分成a0个等价类，等价类中的数模a0的值相同，举
个例子，a0=3，我们可以将0,1,2,3,4,5,6划分成(0,3,6)(1,4)(2,5)这三个
等价类，如果相同等价类中的某个数能被组合，那么比它大的所有在该等价
类中的数必然能被组合出来。所以现在只要求出每个等价类中的最小的能被
组合出来的数，然后取所有等价类中最小数的最大值L，L-a[0]就是问题的
答案（原因很简单，因为L能被组合出来，比L大的并且在同一等价类中的数
必然能通过加上若干个a[0]来求得，于是L-a[0]就成了最大不能组合数）。
    于是问题就转化成了如何在相同等价类中找到最小的那个能被ai组合出
来的数。可以利用最短路来求，最短路的key信息就是它本身值的大小，如果
两个数x,y, (x + ai) % a0 == y % a0，那么我们就在x和y之前连上一条权
值为ai的边，构图完成后就可以从0这个点开始搜了，最后遍历0到a[0]-1找
到最大的那个数L即可。
*/

#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;

#define maxn 5010
#define inf 200000000

int a[500];

struct Point {
    int val;
    int mod_val;
    int dis;
    Point(int _v, int _mv, int _d) {
        val = _v;
        mod_val = _mv;
        dis = _d;
    }
    friend bool operator < (Point a, Point b) {
        return a.dis > b.dis;
    }
};

int dis[maxn], nv[maxn];
priority_queue < Point > Q;

int gcd(int a, int b) {
    if(b == 0)
        return a;
    return gcd(b, a%b);
}

int main() {
    int n;
    int i;
    while(scanf("%d", &n) != EOF) {
        int G = 0;
        for(i = 0; i < n; i++) {
            scanf("%d", &a[i]);
            if(!i)
                G = a[0];
            else
                G = gcd(G, a[i]);
        }
        if(G != 1) {
            printf("INF\n");
            continue;
        }

        sort(a, a + n);
        for(i = 0; i < a[0]; i++) {
            dis[i] = inf;
        }
        dis[0] = 0;
        nv[0] = 0;
        while(!Q.empty()) {
            Q.pop();
        }
        Q.push(Point(0, 0, 0));

        while(!Q.empty()) {
            Point id = Q.top();
            Q.pop();
            for(i = 0; i < n; i++) {
                int nex = (id.mod_val + a[i]) % a[0];
                if(id.dis + a[i] < dis[nex]) {
                    dis[nex] = id.dis + a[i];
                    nv[nex] = id.val + a[i];
                    Q.push(Point(nv[nex], nex, dis[nex]));
                }
            }
        }
        int Max = 0;
        for(i = 0; i < a[0]; i++) {
            if(dis[i] != inf && nv[i] > Max) {
                Max = nv[i];
            }
        }
        printf("%d\n", Max - a[0]);
    }
    return 0;
}

英雄哪里出来 2011-04-05 19:01 发表评论