いくつかの数論およびその他の問題の解決策

P3601 チェックインに関する質問

トピックの背景

関数を定義します。qiandao(x) は、x 以下であり、x と素数ではない数値の数です。

この質問はサインインの質問として使用されます。l と r が与えられると、次の式の結果を見つける必要があります。

$$\sum _{私=l}qiandao\left(x\right)mod666623333\_\_\_\_$$

入力フォーマット

2 つの整数 l、r の行。

出力フォーマット

1 行につき 1 つの整数が答えを表します。

指示/ヒント

データの 30% については、$l、r\le 10^3$。

データの 60% については、$l、r\le 10^7$。

データの 100% について、$1\le 私\le r\le 10^{12}、r-私\le 10^6$。

答え

タイトルから、qiandao ( x ) = x − ϕ ( x ) qiandao(x)=x−\phi(x) であることがわかります。
$$qiandao\left(x\right)\_\_=x-\varphi \left(x\right)$$
ここで、$\varphi \left(x\right)$はオイラー関数です。
正の整数 n の場合、オイラー関数は、n 以下の正の整数の中で n と互いに素な数の数です。
$$\varphi \left(x\right)=\prod _{i=0}n(1-\frac{}{p_{}})$$
其中$p_{}$nnのために$n$の素因数。
各素因数$p_{}$、$p_{}$nを npi \frac n{p_i}に分割できます。$\frac{}{p_{}}$パーツ、各パーツには素因数$p_{}$。つまり、品質係数pi p_i は1~n から抽出されます。$p_{}$その数の確率は$\frac{}{p_{}}$。したがって、n を含まない素因数の確率は${\prod }_{i=0}^{}(1-\frac{}{p_{}})$、確率に n を乗じた値は、互いに素な数の数になります。より正式な説明は、包含と除外の原則。しかし本質的には確率で説明するのと何ら変わりはなく、ベン図で推論することができます。

オイラー関数を理解した後は、問題は簡単です。
通常、オイラーを使用して素数をふるい分けると、オイラー関数を見つけることができます。
次の式を使用します。
$$\varphi (p\ast y)=\{\begin{array}{rcl}p\varphi \left(y\right)& yには因数pがあります& \\ (p-1)\varphi (y& y\; には因数& \end{array}$$
ただし、この問題のrの範囲は大きすぎ、rlの範囲は小さすぎてオイラー関数を直接計算することはできません。オイラー関数の値を更新するには、 √rの範囲内の素数を使用する必要があります。l~rの範囲。なお、残りの数が１でない場合は、 √ｒより大きい素数がまだ残っており、再度処理する必要があることを意味する。

コード

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

#define ll long long
#define MOD 666623333
#define phi(x) _phi[(x)-l]
#define remain(x) _remain[(x)-l]

const int N = 1e6 + 5;
ll l, r;
ll prime[N], _phi[N], _remain[N], tot;
bool notPrime[N];
void EulerSieve(ll siz) {
    
    
  for (ll i = 2; i < N; i++) {
    
    
    if (!notPrime[i]) prime[tot++] = i;
    for (int j = 0; j < tot && i * prime[j] < N; j++) {
    
    
      notPrime[i * prime[j]] = true;
      if (i % prime[j] == 0) break;
    }
  }
}
int main(int argc, char const *argv[]) {
    
    
  ios::sync_with_stdio(false), cin.tie(0);
  cin >> l >> r;
  EulerSieve(0);
  for (ll i = l; i <= r; i++) remain(i) = phi(i) = i;
  for (int i = 0; prime[i] * prime[i] <= r; i++) {
    
    
    ll p = prime[i];
    for (ll j = ((l + p - 1) / p) * p; j <= r; j += p) {
    
    
      phi(j) = phi(j) / p * (p - 1);
      while (remain(j) % p == 0) remain(j) /= p;
    }
  }
  ll ans = 0;
  for (ll i = l; i <= r; i++) {
    
    
    if (remain(i) != 1) {
    
    
      phi(i) = phi(i) / remain(i) * (remain(i) - 1);
    }
    ans = (ans + i - phi(i)) % MOD;
  }
  cout << ans;
  return 0;
}

P1593 要因と項目の説明

2 つの整数 a と b を入力し、${ある}^b$の因数和

結果が大きすぎるため、モジュロ 9901 の結果を出力するだけです。

入力フォーマット

2 つの整数 a と b については 1 行のみ。

出力フォーマット

9901 を法とする答えの結果を表す整数を含む行を出力します。

指示/ヒント

すべてのテスト ポイントについて、$1\le ある\le 5\times 10^7、0\le b\le 5\times 10^7$。

答え

数字$x\; は$素因数の積に分解できます
$$バツ=p_1^{k_{}}{p}_2^{k_{}}。。。p_n^{k_{}}$$
f ( x ) f(x)を定義します。$f\left(x\right)$はxxです$x$の因子和
$$f\left(x\right)=\prod _{i=1}\sum _{k=0}^{k_{}}{p}_{私}^{}$$
それを証明しましょう

令$y=p_2^{k_{}}。。。p_n^{k_{}}$、$y$のすべての因数$p_{}$p 1 k 1 − 1 p_1^{k_1-1}を掛けます$p_1^{k_{}-}$2 つのペアの組み合わせはたまたまxxになります$x$などの係数にp 1 2 p_1^2を乗算します。$p_1^{}$そして$p_1^{k_{}-}$ペアリングも可能です。
すると、以下の漸化式が得られます。
$$f\left(x\right)=f\left(y\right)\sum _{k=0}^{k_{}}{p}_1^{}$$
明らかに、解凍を続けると、最初の式が完成します。
次に、等比数列の合計公式を使用して
$$f\left(x\right)=\prod _{i=1}\frac{p_{私}^{k_{}+1}-}{p_{}-1}$$
对于$p_{私}^{k_{}+1}$割り算pi − 1 p_i-1の場合、高速なべき乗で解きます。$p_{}-1$、結果はモジュロである必要があるため、$p_{}-1$を pi − 1 p_i-1で乗算するように変更します。$p_{}-1$の逆数

フェルマーの小定理

逆元の定義とフェルマーの小定理によると ( a は p の倍数ではありません)
$$\begin{gathered} a\ast x\equiv 1\left(modp\right)\_\_ \\ {ある}^{p-1}\equiv 1\left(modp\right)明らか \end{gathered}$$
にaa$$\_$$$a$和${ある}^{p-2}$は互いに逆数です。ここまでは基本的に解決しました。
特に a が p の倍数の場合。$p_{}-1\equiv 0\left(mod9901\right)イコール$pi ≡ 1 ( mod 9901 ) p_i\equiv1 (mod\
9901$)$$p_{}\equiv 1(mod9901)$
代入原求和公式
$$\begin{gathered} うーん\_\_=\left(p_{}mod9901\right)\_\_{}^0+\left(p_{}mod9901\right)\_\_+。。。+\left(p_{}mod9901\right)\_\_{}^{k_{}} \\ うーん\_\_=k_{}+1 \end{gathered}$$

拡張ユークリッド アルゴリズム

上記の逆元を求める方法に加えて、拡張ユークリッド アルゴリズムを使用することもできます。
ユークリッド アルゴリズムの目的は、$gcd(a,b)=\times \_+$xx$年$$まで$に$x$和$y$
x と a が mod p の意味で逆数である場合。すると、次の方程式
$$\times \_+kp\_=1$$
以下は、拡張ユークリッド アルゴリズムが
次の 2 つの式を持つこと
$$\begin{gathered} \times \_+によって\_=gcd(a,b) \\ bx{\_}^{』}+\left(amまたはdb\right)および\_{}^{』}=gcd(b,amodb)\_\_ \end{gathered}$$
又因として$gcd(b,amodb)\_\_=gcd(a,b)$
$$\begin{gathered} bx{\_}^{』}+\left(amまたはdb\right)および\_{}^{』}=\times \_+によって\_ \\ たった今: \\ \{\begin{array}{lc}バツ=y^{』}& \\ y={バツ}^{』}-\lfloor \frac{}{b}\rfloor y^{}& \end{array} \end{gathered}$$
したがって、x と y を解くには、 x ' x'を解くだけで済みます。${バツ}^{「}$，$y^{\text{'}}$ 、最終的に b = 0 、x = 1、y = 0 の場合の b = 0 、x = 1、y = 0 の場合の再帰境界を見つけます。$いつb=0、バツ=1、y=0$

コード

#include <bits/stdc++.h>
using namespace std;
const int N = 5e7 + 5;
int a, b;
#define MOD 9901
void getFactors(int x, vector<pair<int, int>> &res) {
    
    
  for (int i = 2; i * i <= x; i++) {
    
    
    if (x % i == 0) {
    
    
      res.push_back({
    
    i, 0});
      while (x % i == 0) {
    
    
        res.back().second++;
        x /= i;
      }
    }
  }
  if (x != 1) {
    
    
    res.push_back({
    
    x, 1});
  }
}
int quick_pow(int p, int x) {
    
    
  p %= MOD;
  int ans = 1;
  while (x) {
    
    
    if (x & 1) {
    
    
      ans *= p;
      ans %= MOD;
    }
    p = (p * p) % MOD;
    x >>= 1;
  }
  return ans;
}
int main(int argc, char const *argv[]) {
    
    
  ios::sync_with_stdio(false), cin.tie(0);
  cin >> a >> b;
  vector<pair<int, int>> f1;
  getFactors(a, f1);
  int ans = 1;
  for (int i = 0; i < f1.size(); i++) {
    
    
    int p = f1[i].first;
    // p^0 + p^1 + ... + p^(n-1)
    int n = f1[i].second * b + 1;
    if (p % MOD == 1) {
    
    
      ans *= n, ans %= MOD;
    } else {
    
    
      // 求 p-1 逆元 还可用扩展欧几里得算法
      int inverse = quick_pow(p - 1, MOD - 2);
      ans *= inverse, ans %= MOD;
      ans *= ((quick_pow(p, n) - 1 + MOD) % MOD), ans %= MOD;
    }
  }
  cout << ans;
  return 0;
}

P1069 細胞分裂のトピックの説明

ハンクス博士は、BT (Bio−Tech Biotechnology) の分野では有名な専門家です。現在、彼は細胞実験の準備をしており、細胞のサンプルを増殖させています。

ハンクス博士は現在、1 から N まで番号が付けられた N 種類の細胞を持っており、タイプ i の細胞は1 秒後に$S_{}$同じ種類の細胞です。次に、特定の種類の細胞から 1 つを選択し、それをペトリ皿に入れて、培養のために自由に分裂できるようにする必要があります。一定の時間が経過した後、ペトリ皿内のすべての細胞を M 個の試験管に分割し、実験用の M 個のサンプルを作成します。ハンクス博士の試験管 M の数は非常に多く、通常のコンピューターの基本データ型ではそのような大きな値 M を格納できませんが、幸いなことに MMM は常にm 1 m_1として表現できます。${メートル}_{}$メートル${メートル}_{}$電力、つまり$M={メートル}_1^{{メートル}_{}}$​

ここで医師は、実験をできるだけ早く開始できるように、どの細胞培養を選択すればよいかを知りたいと考えています。

入力フォーマット

最初の行には、セルの種類の数を表す正の整数 N があります。

2 行目には、2 つの正の整数${メートル}_{}、{メートル}_{}$スペースで区切られています。これは試験管の総数を意味します$M={メートル}_1^{{メートル}_{}}$。

3 行目には N 個の正の整数があり、i 番目の数値$S_{}$1秒後に同じ種類のセルに分割できるi番目の種類のセルの数を示します。

出力フォーマット

細胞が培養されてから実験を開始できるようになるまでの最小時間 (秒単位) を表す整数。

ハンクス博士がどのセルを選択しても要件が満たされない場合は、整数 -1 を出力します。

答え

この問題の直接因数分解は非常に簡単です。
ただし、最大公約数を繰り返し抽出し、互いに素な部分を生成し、それを削除する別の方法もあります。少し複雑なのは、最後の再帰終了の状況です。この割り算の判断方法について言えば、高校の数学の先生も言っていましたが、以前はなんとも思わなかったのですが、今では高校の数学の先生の方が優れていると感じることが多くなりました。

#include <bits/stdc++.h>
using namespace std;
#define N 30005
int p[N], n, m1, m2, top;
int np1[N], np2[N];
bool vis[N];
void prime_factorization(int x, int res[]) {
    
    
  memset(res, 0, sizeof(res[0]) * top);
  for (int j = 0; j < top && p[j] <= x; j++) {
    
    
    while (x % p[j] == 0) x /= p[j], res[j]++;
  }
}

int main(int argc, char const *argv[]) {
    
    
  ios::sync_with_stdio(false), cin.tie(0);
  cin >> n;
  cin >> m1 >> m2;
  for (int i = 2; i <= m1; i++) {
    
    
    if (!vis[i]) p[top++] = i;
    for (int j = 0; j < top && i * p[j] <= m2; j++) {
    
    
      vis[i * p[j]] = true;
      if (i % p[j] == 0) break;
    }
  }
  if (m1 == 1 || m2 == 0) {
    
    
    cout << "0";
    return 0;
  }
  prime_factorization(m1, np1);
  int ans = INT_MAX;
  for (int i = 0, t; i < n; i++) {
    
    
    cin >> t;
    prime_factorization(t, np2);
    int t_ans = -1;
    for (int j = 0; j < top; j++) {
    
    
      if (np1[j] == 0) continue;
      if (np2[j] == 0) {
    
    
        t_ans = -1;
        break;
      }
      t_ans = max((np1[j] * m2 + np2[j] - 1) / np2[j], t_ans);
    }
    if (t_ans >= 0) ans = min(ans, t_ans);
  }
  cout << (ans == INT_MAX ? -1 : ans);
  return 0;
}

P2671 合計トピックの説明

細長い紙を均等に n 個のグリッドに分割し、各グリッドに 1 から n までの番号を付けます。各グリッドは色$色\_\_\_{\_}_{}$[ 1 , m ] [1, m]の場合$[1、m]\; は$整数を表します)、数値$番号\_\_\_\_{\_}_{}$。

特別な 3 つ組を定義します: (x, y, z), x, y, z はすべて紙テープ上のグリッドの番号を表します。ここでの 3 つ組は次の 2 つの条件を満たす必要があります: xyz は整数、x <
$$\begin{gathered} xyzは整数です。バツ<y<z、y-バツ=z-y \\ 色\_\_\_{\_}_{}=色\_\_\_{\_}_{} \end{gathered}$$
上記の条件を満たすトリプルの小数は、$(\times +z)\times (番号\_\_\_\_{\_}_{}+番号\_\_\_\_{\_}_{}）$。テープ全体のスコアは、条件を満たすすべてのトリプルのスコアの合計として指定されます。この端数は非常に大きくなる場合があります。テープ全体の端数を出力し、それを$10、007$から得られる余り

入力フォーマット

最初の行は、スペースで区切られた 2 つの正の整数 n と m です。n は紙テープのグリッドの数を表し、m は紙テープの色の数を表します。

2 行目にはスペースで区切られた n 個の正の整数があり、i 番目の数値は i 番のグリッドに書かれた数値です。

3 行目にはスペースで区切られた n 個の正の整数があり、i 番目の数値の色は、表の用紙上の i 番目の数値グリッドの色です。

出力フォーマット

目的のテープ部分を 10007 で割った余りを表す整数。

答え

この質問では、x と y は両方とも奇数か偶数であることが明らかです。そこで、次のテーブルを色とパリティで分類し、最後にトラバースして 2 つを選択してスコアを計算します。
しかし、この質問のデータは比較的大きい$O\left(n^2\right)$タイムアウトになります。
しかし、O(n) 時間の計算量に削減できる次の式があります。

下面推导一下下面公式
$$\sum _{i=1}\sum _{j=i+1}({\_}_{}+{ある}_{})(b_{}+b_{}）=(n-2)\sum _{i=1}{ある}_{}{b}_{}+\sum _{i=1}{ある}_{}\sum _{j=1}{b}_{}$$
恥ずかしながら${ある}_{}{b}_{}$,可由$({\_}_{}+{ある}_{})(b_{}+b_{})$が生成されます。ここで、jji ≠ ji \neq jである限り、$j\; は自由です$$私\ne j$個の制約があるため、合計でn − 1 n-1 個なります。$n-1$ jj$jが$選択可能です。つまり$(n-1){\_}_{}{b}_{}$,对于${ある}_{}{ある}_{}且i\ne j$两个变量都固定，则只有一个。写成公式如下
$$\sum _{i=1}\sum _{j=i+1}({\_}_{}+{ある}_{})(b_{}+b_{}）=(n-1)\sum _{i=1}{ある}_{}{b}_{}+\sum _{i=1}{ある}_{}\underset{j\in \{x|x\in N^{+}、x\le n、x\ne 私\}}{}{b}_{}$$

#include <bits/stdc++.h>
using namespace std;
#define N 100005
#define MOD 10007
int m, n, ans = 0;
int nums[N];
vector<int> colors[N][2];

void solve(const vector<int> &ids) {
    
    
  int n = ids.size();
  if (n < 2) return;
  int sum = 0;
  for (int i = 0; i < n; i++) {
    
    
    sum += nums[ids[i]];
    sum %= MOD;
  }
  int ab = 0, tmp = 0;
  for (int i = 0; i < n; i++) {
    
    
    int id = ids[i];
    ab += ((id % MOD) * (nums[id] % MOD));
    ab %= MOD;
    tmp += (id * sum);
    tmp %= MOD;
  }
  ab *= (n - 2), ab %= MOD;
  ans += tmp, ans %= MOD;
  ans += ab, ans %= MOD;
}
int main(int argc, char const *argv[]) {
    
    
  ios::sync_with_stdio(false), cin.tie(0);
  cin >> n >> m;
  for (int i = 1; i <= n; i++) {
    
    
    cin >> nums[i];
  }
  for (int i = 1, t; i <= n; i++) {
    
    
    cin >> t;
    colors[t][i & 1].push_back(i);
  }
  for (int i = 1; i <= m; i++) {
    
    
    solve(colors[i][0]);
    solve(colors[i][1]);
  }
  cout << ans;
  return 0;
}