hdu 4407 Sum 容斥原理

题意很简单，就是给你一个数组大小为n的值从1到n，之后有m次操作，要么修改前面的数组中的某一项，要么是输出从x到y（包括边界）中的数与p互质的数的和。由于m很小（m<=1000）故，将修改的部分保存下来之后统计输出时，在判断修改的部分是否与p互质，若是要修改原来的，在修改现在的。

注意，就是多次修改同一个地方，只记录最后一次。

对于统计从x到y的与p互质数的和，有结果=数1到y的满足要求的结果-数1到x-1的满足要求的结果。

而从1开始到n的数中与p互质的数的和的求法，就是个容斥原理的算法。

剔除p中单个素因子的倍数，加上两个因子的倍数，接着在剔除三个素因子的倍数，直到所有的素因子结束。

。/**   
 * @Title: HDU4407.java 
 * @Package com.wangzhu.hdu 
 * @Description: TODO
 * @author 王竹
 * @date 2012-9-22 下午7:40:27 
 * @version V1.0   
 *
 */
package com.wangzhu.hdu;

import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.Scanner;

/**
 * @ClassName: HDU4407
 * @Description: TODO
 * @author 王竹
 * @date 2012-9-22 下午7:40:27
 * 
 */
public class HDU4407 {

    public static void main(String[] args) {
        // System.setIn(new FileInputStream("data.in"));
        Scanner cin = new Scanner(new BufferedInputStream(System.in));
        int t, n, m, cas, x, y, c, p;
        initPrime();
        while (cin.hasNext()) {
            t = cin.nextInt();
            while (t-- > 0) {
                n = cin.nextInt();
                m = cin.nextInt();
                node = new Node[m + 1];
                lastIndex = new int[MAXN];
                nodeLen = 0;
                for (int i = 0; i < m; i++) {
                    cas = cin.nextInt();
                    if (cas == 2) {
                        x = cin.nextInt();
                        c = cin.nextInt();
                        node[nodeLen] = new Node(x, c);
                        lastIndex[x] = nodeLen++;
                    } else {
                        x = cin.nextInt();
                        y = cin.nextInt();
                        p = cin.nextInt();
                        work(x, y, p, n);

                    }
                }
            }
        }
        cin.close();
    }

    private final static int MAXN = 400001;
    static int[] lastIndex;
    private final static int VAL = 1000;
    static int[] prime = new int[VAL];
    static boolean[] isPrime = new boolean[VAL];
    static int primeLen;

    public static void initPrime() {
        Arrays.fill(isPrime, false);
        primeLen = 0;
        prime[primeLen++] = 2;
        for (int i = 4; i < VAL; i += 2) {
            isPrime[i] = true;
        }
        for (int i = 3; i < VAL; i += 2) {
            if (!isPrime[i]) {
                prime[primeLen++] = i;
            }
            for (int j = 0; (j < primeLen) && (i * prime[j] < VAL); j++) {
                isPrime[i * prime[j]] = true;
                if (i % prime[j] == 0) {
                    break;
                }
            }
        }
    }

    static Node[] node;
    static int nodeLen;

    static int[] primeFactor; // 存储素因子
    static int primeFactorLen;

    /**
     * 分解数p获得其素因子
     * 
     * @param p
     */
    public static void mkPrimeFactor(int p) {
        primeFactor = new int[VAL];
        int temp = (int) Math.sqrt(1.0 * p);
        primeFactorLen = 0;
        for (int i = 0; (i < primeLen) && (prime[i] <= temp); i++) {
            if (p % prime[i] == 0) {
                primeFactor[primeFactorLen++] = prime[i];
                while (p % prime[i] == 0) {
                    p /= prime[i];
                }
            }
        }
        if (p > 1) {
            primeFactor[primeFactorLen++] = p;
        }
    }

    private static void work(int x, int y, int p, int n) {
        mkPrimeFactor(p);
        long res = getSum(y) - getSum(x - 1);
        for (int i = 0; i < nodeLen; i++) {
            if (node[i].x >= x && node[i].x <= y) {
                // 若是多次修改同一个地方，则只取最后一次
                if (i != lastIndex[node[i].x]) {
                    continue;
                }
                if (isCoPrime(node[i].x, p)) {
                    res -= node[i].x;
                }
                if (isCoPrime(node[i].c, p)) {
                    res += node[i].c;
                }
            }
        }
        System.out.println(res);
    }

    private static long getSum(int i) {
        long res = (long) i * (i + 1) / 2;
        res -= dfs(0, i, 1);
        return res;
    }

    private static boolean isCoPrime(int c, int p) {
        return gcd(c, p) == 1;
    }

    /**
     * 最大公约数
     * 
     * @param a
     * @param b
     * @return
     */
    public static long gcd(long a, long b) {
        long r;
        if (a < b) {
            r = a;
            a = b;
            b = r;
        }
        while (b != 0) {
            r = a % b;
            a = b;
            b = r;
        }
        return a;
    }

    /**
     * 容斥原理 获得在n下所有与p互质的数的和
     * 
     * @param start
     * @param n
     * @param now
     * @return
     */
    private static long dfs(int start, int n, long now) {
        long res = 0, temp;
        for (int i = start; i < primeFactorLen; i++) {
            temp = lcm(now, primeFactor[i]);// 每一个开始，之后就是其最小公倍数
            res += getPrimeSum(temp, n) - dfs(i + 1, n, temp);
        }
        return res;
    }

    /**
     * 最小公倍数
     * 
     * @param now
     * @param i
     * @return
     */
    private static long lcm(long now, long i) {
        return (long) now / gcd(now, i) * i;
    }

    private static long getPrimeSum(long num, int n) {
        long temp = n / num;
        return temp * (temp + 1) / 2 * num;
    }

}

class Node {
    int x;
    int c;

    public Node(int x, int c) {
        this.x = x;
        this.c = c;
    }
}