jzoj 3456 恭介的法则

在一个充满魔法的世界里,主角们必须解决一个编程难题来纠正世界的法则。难题要求找出所有正整数对(x,y),使得1/x + 1/y = 1/n!。本文介绍了问题背景及解决方案。

Description

终于,在众亲们的奋斗下,最终boss 恭介被关进了库特设计的密室。正当她们松了一口气时,这个世界却发生了天翻覆地的变化:地面开始下沉,天空开始变成血红色,海水沸腾……一幅世界末日的图景。美鱼从她手中的古籍《若山牧水诗歌集》中发现了原因:白鸟は かなしからずや 空の青 海のあをにも 染まずただよふ 。大(xia)意(shuo)就是狡猾的恭介在创造这个世界的时候就篡改了法则。而这个法则的起源,就是一只生死之间的猫。这个猫被关在一个黑盒子里,盒子里有两个毒气罐,如果有任意一个毒气罐被打开那么猫将会被杀死,法则也能得到纠正。然而外界能控制的仅仅是这两个毒气罐被打开的概率。假设第一个毒气罐被打开的概率为1/x,第二个毒气罐为1/y(x,y 为正整数),那么当两个概率和为1/(n!)时,猫将会被莫名其妙地杀死。现在美鱼想知道,有多少对(x,y)可以让猫被莫名其妙杀死。

Input

一行,一个正整数n

Output

一行,满足题意的(x,y)对数。

Sample Input

6

Sample Output

135

Data Constraint

对于30%的数据 n<=6
对于60%的数据 n<=50
对于100%的数据 n<=700000


Solution

题目求的是满足1x+1y=1n!xyNxy

1x+1y=x+yxy=1n!
xyx+y=n!
xy=n!(x+y)=n!x+n!y
xyn!x=(yn!)x=n!y
x=n!yyn!
由于,x,y都是正整数,则有
yn!>0y>n!
(yn!)|n!y
设y=n!+k
x=n!yyn!=n!(n!+k)k=(n!)2+n!kk
为了满足x,y都是正整数,k|(n!)2
所以答案为(n!)2的因子个数


#pragma GCC opitmize("O3")
#pragma G++ opitmize("O3")
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;

#define N 700100
#define P 10000000
#define LL long long

int prime[N],isprime[N];
LL num[N];
LL ans[10000];
int n,l;

__attribute__((optimize("-O3")))
void init()
{
    scanf("%d",&n);
    memset(isprime,0,sizeof(isprime));
    for (int i=2;i<=n;++i)
    {
        if (isprime[i]==0) prime[++prime[0]]=i;
        for (int j=1;j<=prime[0];++j)
        {
            int t=i*prime[j];
            if (t>n) break;
            isprime[t]=t;
            if (i%prime[j]==0) break;
        }
    }
    for (int i=1;i<=prime[0];++i)
    {
        int j=n;
        while (j) num[i]+=(j/=prime[i]);
    }
    for (int i=1;i<=prime[0];++i)
      num[i]=num[i]*2+1;
//  for (int i=1;i<=prime[0];++i) printf("%lld ",num[i]);
//  printf("\n");
}

__attribute__((optimize("-O3")))
void cheng()
{
    memset(ans,0,sizeof(ans));
    l=1;
    ans[1]=1;
    for (int i=1;i<=prime[0];++i)
    {
        LL t=0;
        //printf("%d\n",i);
        for (int j=1;j<=l;++j)
        {
            ans[j]=ans[j]*num[i]+t;
            t=ans[j]/P;
            ans[j]%=P;
        }
        if (t!=0)
        {
            l++;
            ans[l]=t;
        }
        /*for (int i=l;i>=1;--i)
        printf("%lld",ans[i]);
      printf("\n%d\n",l);*/
    }
    for (int i=l;i>=1;--i)
    {
        if (i!=l)
        {
            int j=P/10;
            while (ans[i]/j==0 && j>0) 
            {
                printf("0");
                j/=10;
            }
        }
      printf("%lld",ans[i]);
    }
    printf("\n");
}

int main()
{
    init();
    cheng();
    return 0;
}

PS

刚开始最后一个点TLE,在同学的帮助下开-O3愉快的过了
全局的
#pragma GCC opitmize("O3")
#pragma G++ opitmize("O3")
某过程前
__attribute__((optimize("-O3")))

### 解题思路 题目要求解决的是一个与图相关的最小覆盖问题,通常在特定条件下可以通过状态压缩动态规划(State Compression Dynamic Programming, SCDP)来高效求解。由于状态压缩的适用条件是状态维度较小(例如K≤10),因此可以利用二进制表示状态集合,从而优化计算过程。 #### 1. 状态表示 - 使用一个整数 `mask` 表示当前选择的点集,其中第 `i` 位为 `1` 表示第 `i` 个节点被选中。 - 定义 `dp[mask]` 表示在选中 `mask` 所代表的点集后,能够覆盖的节点集合。 - 可以通过预处理每个点的邻域信息(包括自身和所有直接连接的点),快速更新状态。 #### 2. 预处理邻域 对于每个节点 `u`,预先计算其邻域范围 `neighbor[u]`,即从该节点出发一步能到达的所有节点集合。这样,在后续的状态转移过程中,可以直接使用这些信息进行合并操作。 #### 3. 状态转移 - 初始化:对每个单独节点 `u`,设置初始状态 `dp[1 << u] = neighbor[u]`。 - 转移规则:对于任意两个状态 `mask1` 和 `mask2`,如果它们没有交集,则可以通过合并这两个状态得到新的状态 `mask = mask1 | mask2`,并更新对应的覆盖范围为 `dp[mask1] ∪ dp[mask2]`。 - 在所有状态生成之后,检查是否某个状态的覆盖范围等于全集(即覆盖了所有节点)。如果是,则记录此时使用的最少节点数量。 #### 4. 最优解提取 遍历所有可能的状态,找出能够覆盖整个图的最小节点数目。 --- ### 时间复杂度分析 - 状态总数为 $ O(2^K) $,其中 `K` 是关键点的数量。 - 每次状态转移需要枚举所有可能的子集组合,复杂度为 $ O(2^K \cdot K^2) $。 - 整体时间复杂度控制在可接受范围内,适用于 `K ≤ 10~20` 的情况。 --- ### 代码实现(状态压缩 DP) ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 25; int neighbor[MAXN]; // 每个节点的邻域 int dp[1 << 20]; // dp[mask] 表示选中的点集合为 mask 时所能覆盖的点集合 int min_nodes; // 最小覆盖点数 void solve(int n, vector<vector<int>>& graph) { // 预处理每个节点的邻域 for (int i = 0; i < n; ++i) { neighbor[i] = (1 << i); // 包括自己 for (int j : graph[i]) { neighbor[i] |= (1 << j); } } // 初始化 dp 数组 memset(dp, 0x3f, sizeof(dp)); for (int i = 0; i < n; ++i) { dp[1 << i] = neighbor[i]; } // 状态转移 for (int mask = 1; mask < (1 << n); ++mask) { if (__builtin_popcount(mask) >= min_nodes) continue; // 剪枝 for (int sub = mask & (mask - 1); sub; sub = (sub - 1) & mask) { int comp = mask ^ sub; if (comp == 0) continue; int new_mask = mask; int covered = dp[sub] | dp[comp]; if (covered == (1 << n) - 1) { min_nodes = min(min_nodes, __builtin_popcount(new_mask)); } dp[new_mask] = min(dp[new_mask], covered); } } } int main() { int n, m; cin >> n >> m; vector<vector<int>> graph(n); for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; graph[u].push_back(v); graph[v].push_back(u); // 无向图 } min_nodes = n; solve(n, graph); cout << "Minimum nodes required: " << min_nodes << endl; return 0; } ``` --- ### 优化策略 - **剪枝**:当当前状态所用节点数已经超过已知最优解时,跳过后续计算。 - **提前终止**:一旦发现某个状态覆盖了全部节点,并且节点数达到理论下限,即可提前结束程序。 - **空间优化**:可以仅保存当前轮次的状态,减少内存占用。 --- ### 总结 本题通过状态压缩动态规划的方法,将原本指数级复杂度的问题压缩到可接受范围内。结合位运算技巧和预处理机制,能够高效地完成状态转移和覆盖判断操作。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值