Wannafly挑战赛14 题解

A

在三维空间中，平面 x = 0, y = 0, z = 0，以及平面 x + y + z = K 围成了一个三棱锥。
整天与整数打交道的小明希望知道这个三棱锥内、上整点的数目。

他觉得数量可能很多，所以答案需要对给定的 M 取模。

思路1:

对于一个三菱锥来说,其是由k+1个直角三角形组成,仅仅考虑其整数点

对于其中一个直角三角形来说,其中的整数点为(i^2 + i) /2

于是三菱锥中的整数点为: 1/2*∑(i^2 + i) (1<=i<=k+1)

由平方和公式: 

于是∑i^2 = (k+1)*(k+2)*(2k+3) / 6 

∑i = (k+1)*(k+2) / 2

1/2*∑(i^2 + i) (1<=i<=k+1)  =  1/12 * (k+1)*(k+2)*(2k+6)

= (k+1) * (k+2) * (k+3) / 6

思路2:

题中的意思就是找到 满足 a + b + c <= n的元组个数:

而 a + b + c <= n 可以转换为 a + b + c + d = n的四元组个数;

利用隔板法,将 k 个 1 分成 4 份,

其中允许a,b,c,d为空,于是我们人为的给a,b,c,d都加上1,于是就满足了隔板法的定义

于是 k + 4个1中有 k + 3 个空位,插入三个板子将其分成4份

就是 C(k+3,3) = (k+1)*(k+2)*(k+3) / 6

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll mod;
int main()
{
    ll k;
    int caset;scanf("%d",&caset);
    while(caset--)
    {
        scanf("%lld%lld",&k,&mod);
        printf("%lld\n",(k+3)*(k+2) % (6*mod) * (k+1) % (6*mod) / 6);
    }
    return 0;
}

C

题意:

给出一个 0 ≤ N ≤ 10⁵ 点数、0 ≤ M ≤ 10⁵ 边数的有向图，

输出一个尽可能小的点集，使得从这些点出发能够到达任意一点，如果有多个这样的集合，输出这些集合升序排序后字典序最小的。

题解:

这里我们分析两个解法:

解法1: Tarjan缩点

通过Tarjan算法进行强连通分量的染色.

对于两个强连通分量a,b来说 有三种情况

1.要么a,b之间没有边相连  ///那么这个子集必须包括 a 的 点 和  b 的点

2.要么 a 能到 b                       ///这个最小子集只需要有a的点即可

3.要么 b 能到 a                       ///这个最小的子集只需要有b的点即可

以上的操作可以通过入度数组来维护

注意从强联通分量选择点时,也应当选择最小的点,最后需要排序

复杂度: O(n+m)

代码:

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5+10;    /// 点数
const int MAXM = 1e5+10;    /// 边数
typedef struct node{
    int to,next;
}Edge;
Edge edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN]; /// Belong数组的值是1~scc
int Index,top;  /// Low 和 DFN 的遍历顺序
int scc;        /// 强连通分量的个数
bool Instack[MAXN];
vector<int> id[MAXN];
void addedge(int u,int v) {
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
void Tarjan(int u) {
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for(int i = head[u];~i;i = edge[i].next) {
        v = edge[i].to;
        if(!DFN[v]) {
            Tarjan(v);
            if(Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if(Instack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if(Low[u] == DFN[u]) {
        scc++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            id[scc].push_back(v);
        }
        while( v != u);
    }
}
void solve(int N) {
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    for(int i=0;i<MAXN;i++) id[i].clear();
    Index = scc = top = 0;
    for(int i=1;i<=N;i++) if(!DFN[i]){
        Tarjan(i);
    }
}
int u[MAXM],v[MAXM],in[MAXN];
vector<int> ans;
void init() {
    tot = 0;
    memset(head,-1,sizeof(head));

    memset(in,0,sizeof(in));
    ans.clear();
}
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(int i=1;i<=m;i++) {
            scanf("%d%d",&u[i],&v[i]);
            addedge(u[i],v[i]);
        }
        solve(n);
        for(int i=1;i<=m;i++) {
            if(Belong[u[i]] == Belong[v[i]]) continue;
            in[Belong[v[i]]]++;
        }
        for(int i=1;i<=scc;i++) sort(id[i].begin(),id[i].end());
        for(int i=1;i<=scc;i++) if(!in[i]) ans.push_back(id[i][0]);
        sort(ans.begin(),ans.end());
        printf("%d\n",(int)ans.size());
        for(int i=0;i<(int)ans.size();i++)
            printf("%d%c",ans[i]," \n"[i+1 == (int)ans.size()]);
    }
    return 0;
}

解法2:

比赛结束后,无意中看到的一种思路

首先我们可以标记所有的点的入度

对于入度为0的点u进行深搜,把所有能到达u的点的父节点标记为u,个人感觉变成了1个以根节点u的树

遍历完后,图中还有一些没有遍历到的节点,这些节点是自成一个环的节点集

对于这些节点进行深搜,因为搜索顺序是从小到大,所以,最小的节点作为了父节点

最后,所有的父节点fnt[i] == i的节点就是我们要的子集

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+10;
vector<int> way[maxn],ans;
int in[maxn];
int fnt[maxn];
void init() {
    ans.clear();
    memset(in,0,sizeof(in));
    memset(fnt,0,sizeof(fnt));
    for(int i=0;i<maxn;i++) way[i].clear();
}
void dfs(int x,int fa) {

    if(fnt[x] == fa) return;
    fnt[x] = fa;
    for(int i=0;i<way[x].size();i++) {
        dfs(way[x][i],fa);
    }
}
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        while(m--) {
            int u,v;
            scanf("%d%d",&u,&v);
            way[u].push_back(v);
            in[v]++;
        }
        for(int i=1;i<=n;i++) if(in[i] == 0) {
            dfs(i,i);
        }
        for(int i=1;i<=n;i++) if(fnt[i] == 0) {
            dfs(i,i);
        }
        for(int i=1;i<=n;i++) if(fnt[i] == i) {
            ans.push_back(i);
        }
        int len = ans.size();
        printf("%d\n",len);
        for(int i=0;i<len-1;i++) printf("%d ",ans[i]);
        printf("%d\n",ans[len-1]);
    }
    return 0;
}