2016 CCPC Hangzhou Onsite(部分题)

D题 - Difference

题意：给你两个数$x$, $K$个数和一个公式$$f(y, K) = \sum_{z\text{ in every digits of }y} z^K (f(233, 2) = 2^2 + 3^2 + 3^2 = 22)$$

要求你找出所有满足$$x = f(y, K) - y$$这个式子的y的数量。

解决：折半枚举法，这个套路其实被用过很多遍，但以前没有研究过它，所以遇到这种题很少会往这个方向去想导致这种水题都难出。系统学习其实是自学的一种很好的途径，以后要形成这种学习意识才对。

废话说了这么多，我们来谈谈这个题。这个题知道方法后就很简单了，我们预处理低位对答案的贡献，然后枚举高位即可。所有位对答案的贡献其实就是$$\sum_{i=1}^{length} (num[i]^k - num[i]*10^i)$$

既然每位相对独立，折半枚举就不存在问题了。

代码：

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const int N = 9 + 5;
const int M = 100000;

map <ll, int> mp[N];
int arry[N];
ll pw[N][N];
ll p10[N];

void init()
{
    for(int i = 0; i < N; ++ i) {
        pw[i][0] = 1;
        for(int j = 1; j < N; ++ j)
            pw[i][j] = pw[i][j-1] * i;
    }
    p10[0] = 1;
    for(int i = 1; i < N; ++ i) {
        p10[i] = p10[i-1] * 10;
    }
    for(int i = 0; i < M; ++ i) {
        int t = i, cnt = 0;
        while(t) {
            arry[cnt ++] = t % 10;
            t /= 10;
        }
        for(int k = 1; k <= 9; ++ k) {
            ll ans = 0;
            for(int j = 0; j < cnt; ++ j)
                ans += pw[arry[j]][k];
            mp[k][ans - 1ll * i] ++;
        }
    }
}

int main()
{
    int T, kase = 1;
    init();
    scanf("%d", &T);
    while(T --) {
        ll x, k;
        ll ans = 0;
        scanf("%lld%lld", &x, &k);
        for(int i = 0; i < M; ++ i) {
            int tmp = i;
            ll sec = x;
            while(tmp) {
                sec -= pw[tmp % 10][k];
                tmp /= 10;
            }
            sec += p10[5] * i;
            if(mp[k].count(sec))
                ans += 1ll * mp[k][sec];
        }
        if(x == 0) ans --;
        printf("Case #%d: %lld\n", kase ++, ans);
    }
    return 0;
}

 

J题 - Just a Math Problem

题意：给你个$n$，要求你求出

$$\sum_{i = 1}^{n} g(i)$$

其中

$$g(i)=2^{f(i)}$$

$f(i)$表示的是$i$的素因子的个数。

解决：此题有两种解法，都是值得大家去学习的。

解法一：利用莫比乌斯函数解决

莫比乌斯函数，他的符号为$\mu$，如果不知道这是什么那么可以把这种解法跳过，以后学习完这个概念后再来研究这种解法。

怎么用这个函数解决这个题呢？

首先我们看一下莫比乌斯函数的一个推导公式

$$\mu^{2}(x) = \sum_{k^2|x}\mu(k)$$

- 公式1

要这个有什么用呢？我们来分析题干上的公式，$g(i)=2^{f(i)}$，这里我们把它理解成$i$的无平方素因子的个数（仔细想想为什么），而$\mu(i)$只有在$i$无平方素因子才会有值，值为$1$, $-1$。所以我们可以将其转换成

$$g(i)=\sum_{d|i}\mu^{2}(d)$$

结合公式1我们得到

$$g(i)=\sum_{d|i}\sum_{k^2|d}\mu(k)$$

由整数的性质再结合题干公式我们得到

$$\sum_{i=1}^{n}=\sum\limits_{k=1}^{n}\mu(k)\sum_{k^2|d}\lfloor \frac{n}{d} \rfloor$$

至此，我们可以枚举$k$，当$k^2$大于n贡献就为0了我们就可以停止枚举，分块求出$$\sum_{k^2|d}\lfloor \frac{n}{d} \rfloor$$的值累加进答案即可。时间复杂度为$O(\sqrt{n}log(n))$。

这种方法有三难，难想，难推，难过。为什么会难过？嗯，这种方法被卡常卡的很厉害。你需要进行各种细节优化才能过。

代码：

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const int N = 1e6 + 5;
const ll MOD = 1e9 + 7;

int mu[N];
int prime[N];
ll g[N], mem[N];
bool vis[N];
int cn;

void init()
{
  memset(mem, -1, sizeof(mem));
  cn = 0;
  mu[1] = 1;
  for(int i = 2; i < N; ++ i) {
    if(!vis[i]) {
      prime[cn ++] = i;
      mu[i] = -1;
    }
    for(int j = 0; j < cn && i * prime[j] < N; ++ j) {
      vis[i * prime[j]] = 1;
      if(i % prime[j] != 0) {
        mu[i * prime[j]] = - mu[i];
      }
      else break;
    }
  }
}

void fadd(ll& a, ll b)
{
  a += b;
  if(a >= MOD) a -= MOD;
}

ll F(ll lim)
{
  if(lim < N && mem[lim] != -1) return mem[lim];
  ll tmp = 0;
  for(ll j = 1, st; j <= lim; j = st + 1) {
    st = lim / (lim / j);
    tmp += (st - j + 1) * (lim / j);
  }
  if(lim < N) mem[lim] = tmp % MOD;
  return tmp % MOD;
}

int main()
{
  init();
  int T, kase = 1;
  scanf("%d", &T);
  while(T --) {
    ll n;
    scanf("%lld", &n);
    int lim = sqrt(n) + 1;
    ll ans = 0;
    for(int i = 1; i <= lim; ++ i) if(mu[i]){
      ans += mu[i] * F(n/i/i);
    }
    printf("Case #%d: %lld\n", kase ++, (ans % MOD + MOD) % MOD);
  }
  return 0;
}

在HDU上测得的状态：

解法二：利用互质关系解决

在逛博客时发现了一个更好的思路，这种解法对$g(i) = 2^{f(i)}$有另一种解释：乘积为$i$且互质的有序数对个数（再想想这是为什么）。

那么我们枚举$i$，再利用容斥计算下$[i+1, n/i]$中有多少个与其互质即可。计算出累加和$sum$还不够，因为是有序对，所以正真的答案为$ans = sum * 2 + 1$。

时间复杂度$O(能过)$

代码：

#include <bits/stdc++.h>
#define lowbit(x) ((x)&(-x))
using namespace std;

typedef long long ll;

const int N = 1e6 + 5;
const ll MOD = 1e9 + 7;

int prime[N];
ll mul[N];
int L[N];
bool vis[N];
int cn = 0;

vector <int> vec[N];

void init()
{
  for(int i = 2; i < N; ++ i) {
    if(!vis[i]) prime[cn ++] = i;
    for(int j = 0; j < cn && prime[j] * i < N; ++ j) {
      vis[prime[j] * i] = 1;
      if(i % prime[j] == 0) break;
    }
  }
  for(int i = 1; i < N; ++ i)
  {
    int cnt = 0, x = i;
    for(int j = 0; j < cn; ++ j) {
      if(prime[j] * prime[j] > x) break;
      if(x % prime[j] == 0) {
        vec[i].push_back(prime[j]);
      }
      while(x % prime[j] == 0) {
        x /= prime[j];
      }
    }
    if(x != 1) vec[i].push_back(x);
  }
  L[1] = 0;
  for(int i = 1; (1<<i) < N; ++ i) {
    L[1<<i] = i;
  }
}

ll cal(int x, ll n)
{
  ll rtn = n - x;
  mul[0] = 1;
  for(int i = 1; i < (1<<(int)vec[x].size()); ++ i) {
    int d = lowbit(i);
    mul[i] = mul[i-d] * -vec[x][L[d]];
    rtn += n / mul[i] - x / mul[i];
  }
  return rtn;
}

int main()
{
  int T, kase = 1;
  init();
  scanf("%d", &T);
  while(T --) {
    ll n, ans = 0;
    scanf("%lld", &n);
    for(int i = 1; 1ll * i * i <= n; ++ i) {
      ans += cal(i, n / i);
    }
    printf("Case #%d: %lld\n", kase ++, (ans * 2 + 1) % MOD);
  }
  return 0;
}

在HDU测得的状态：

 

感谢观看，如有问题，欢迎在评论中指出。