qbxt day6

qbxt day6

Problem A. 最佳进制

File: divisors.*
Time limit: 1s
Memory limit: 256MB
如今我们最常用的是十进制，据说这是因为人有十根手指。
但事实上这并不是十分方便，10 只有四个因子 1、2、5、10，像1/3,1/6这些分数在十进制下的小数表式就不是很优美。在这种要求下，12、24 甚至 60 进制会更好一些。
现在想求出不超过 n 的最佳进制数，也就是拥有最多的因子。
Input
第一行包含一个整数 n，(1 ≤ n ≤ 1e16 )。
Output
输出一个数 c，表式最佳进制数。
Examples
Input 100
Output 60
Subtasks
对于 20% 的数据，n ≤ 100。
对于 40% 的数据，n ≤ 1e5。
对于 60% 的数据，n ≤ 1e9 。
对于 100% 的数据，k ≤ 1e16 。

根据质因数分解
※因数个数 ：（a1 +１）＊（a2＋１）＊．．．．．＊（an＋１）
暴力即可找到n以前拥有最大因数个数的数
要想找最多因子数，由※知应该让因子小的幂尽量大，由此出发搜索即可

#include<iostream>
#include<cstdio>
#include<cstring>
#include <cstdlib>
using namespace std;
typedef long long ll;
const ll maxn=1e16+1;
ll n,ans=1,maxd=1;
int prime[]={0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41};
//prime[x]为质因数，sum为当前积，nowd为当前的（幂+1）的积 即因子个数，lim是一个幂限制
void dfs(int x,ll sum,ll nowd,ll lim)
{
    if(nowd>maxd||(nowd==maxd&&sum<ans))
        maxd=nowd,ans=sum;
    if(x>13) return;
    for(int i=1;sum*prime[x]<=n&&i<=lim;i++)
        dfs(x+1,sum*=prime[x],nowd*(i+1),i);//保证小的质数的幂最大 
}
int main()
{
    scanf("%lld",&n);//忘加取址符 
    if(n)dfs(1,1,1,100);
    printf("%lld",ans);
    return 0;
}

Problem B. 树

File: tree.*
Time limit: 1s
Memory limit: 256MB

给出一棵节点数为 n 的有根树，现在需要给每个节点标号，要求对应子树同构的节点标号相同。

若图 G1,G2 同构，则存在 G1 点集和 G2 点集之间的双射 ϕ，满 u → v 是 G1 中的 条边当且仅当 ϕ(u) → ϕ(v) 是 G2 中的一条边。

Input
第 一行包含一个数 n(1<=n<=1e5)，表示树的点数。
第 二行包含 n-1 个数，第 i 个数表示编号为 i + 1 点的父节点编号，满足父节点的编号小于子节点，根节点编号为 1。

Output
一行包含 n 个数，表示节点标号，标号大小范围在 1 到 n 之间。如果有多种标号，给出字典序最小的标号。

Examples
Input
9
1 2 2 1 5 5 7 7
Output
1 2 3 3 4 3 2 3 3

Subtasks
对于 30% 的数据，n<=12。
对于 50% 的数据，n<=100。
对于 100% 的数据，n<=1e5。

思路：

对于每个节点，统计每个儿子的hash值
对哈希值排序，得到此节点的值
暴力递归对拥有不同哈希值的点进行染色

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
const int maxn=1e5+10;
int fa,head[maxn],tot,n,vis[maxn],dis[maxn];
map < vector<int>,int> q; //映射不定长数组，神奇QAQ 
int read()
{
    int t=1,x=0;
    char ch=getchar();
    while(ch<'0'||ch>'9'){  if(ch=='-')t=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){    x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return t*x;
}
struct egde
{
    int u,v,next;
}e[maxn];
void add(int x,int y)
{   e[++tot]=(egde){x,y,head[x]};   head[x]=tot;}
int dfs(int x)
{
    vector<int> t;
    for(int i=head[x];i;i=e[i].next)
        t.push_back(dfs(e[i].v));//得到的是vis，到没有子节点为止
    sort(t.begin(),t.end());//排序判断同构  
    if(!q[t])   q[t]=++tot;
    vis[x]=q[t];
    return vis[x];//返回vis数组 即颜色（同构编号） 
}
int main()
{
    n=read();
    for(int i=2;i<=n;i++)
        fa=read(),add(fa,i);
    tot=0;  dfs(1);   tot=0;
    for(int i=1;i<=n;i++)
    {
        if(dis[vis[i]]==0)//要求父亲编号小于儿子的编号 
        dis[vis[i]]=++tot;
        printf("%d ",dis[vis[i]]);
    }
    return 0;
}

method.2

#include<iostream>
#include<cstdio>
#include<cstring>
#include<map>
#include<algorithm>
using namespace std;
#define ll long long

const int maxn = 100000 + 100;
const int mod = 497476431;
const int base = 100000;

int n;
struct edge{
    int u,v;
    int next;
}e[maxn];
int head[maxn],tot = 0,vis[maxn],dis[maxn];

int read() {
    int x = 0, f = 1;
    char ch = getchar();
    while(ch < '0' || ch > '9') {
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}

void add(int u, int v ) {
    e[++tot] = (edge) {u,v,head[u]};
    head[u] = tot;
}

map<int, int> q;


int dfs(int x) {
    int a[1001];
    memset(a,0,sizeof(a));
    int o = 0;
    for(int i = head[x]; i; i = e[i].next) {
        int v = e[i].v;
        a[++o] = dfs(v);
    }
    sort(a + 1, a + o + 1);
    int tp = 1;
    for(int i = 1; i <= o; i++) {
        tp = ( (tp * base) % mod + a[i] ) % mod;
    }
    if(!q[tp]) q[tp] = ++tot;
    vis[x] = q[tp];
    return vis[x];
}

int main() {
    freopen("tree.in","r",stdin);
    freopen("tree.out","w",stdout);
    n = read();
    for(int i = 2; i <= n; i++) {
        int l = read();
        add(l,i);
    }
    tot = 0;
    dfs(1);
    tot = 0;
    for(int i = 1; i <= n; i++) {
        if(!dis[vis[i]]) {
            dis[vis[i]] = ++tot;
        }
        cout<<dis[vis[i]]<<' ';
    }
    return 0;
}

Problem C. 关系

File: relations.*
Time limit: 1s
Memory limit: 256MB

有一个二元关系 R，R 可以被表示成 n*n 的布尔数组。
现在希望找到长度都为 n 的数组 f 和 g，要求满 R（x，y）= 1 当且仅当 f (x)<=g(y)。

Input
第一行包含一个整数 n(1<=n<=1000)，表示数组的大小。
接下来的 n 行表示二元关系 R。

Output
第一行输出能否找到数组 f 和 g，如果能找到输出 YES，否则输出 NO。 -1e9 <=fi; gi<= 1e9
第二行输出 n 个整数，表示数组 f 。
第三行输出 n 个整数，表示数组 g 。

Examples
Input
3
111
110
100

Output
YES
0 1 2
2 1 0

Subtasks
对于 20% 的数据，n<=10。
对于 50% 的数据，n<=100。
对于 100% 的数据，n<=1000。

当R(i，j )= 1时 f[i] <= g[i]
当R(i，j )= 0时 f[i] > g[i]
所以可以建图来解决
定义 u -> v 为 f[u] < g[v]
根据拓扑排序，得到拓扑序，f，g数组就可以用拓扑序来表示
若有环，就是NO；
建二层图，由大到小建立边，这样在两层图上跳；

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
typedef long long ll;
const int maxn=1e4+10;
int n,head[maxn],vis[maxn],val[maxn],tot;
string m;//一个字符串 
struct egde 
{
    int u,v,next;
}e[maxn];
void add(int x,int y)
{
    e[++tot]=(egde){x,y,head[x]};
    head[x]=tot;    vis[y]++;
}
void topo()
{
    queue<int>q;
    for(int i=1;i<=2*n;i++) if(!vis[i]) q.push(i);
    while(!q.empty())
    {
        int k=q.front();    q.pop();
        for(int i=head[k];i;i=e[i].next)
        {
            int to=e[i].v;
            vis[to]--;      if(!vis[to]) q.push(to);
            val[to]=max(val[to],val[k]+1);
        }
    }
}
int main()
{
    //  freopen("relations.in","r",stdin);
   // freopen("relations.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        cin>>m;
        for(int j=1;j<=n;j++)
        if(m[j-1]=='0') add(i,j+n);//fx>gx   gx在二层图上 
        else add(j+n,i);//j+n=>双层图 
    }
    topo();
    for(int i=1;i<=2*n;i++) if(vis[i]) {cout<<"NO";return 0;}
    cout<<"YES"<<endl;
    for(int i=1;i<=n;i++)   cout<<val[i]<<" ";  cout<<endl;
    for(int j=1;j<=n;j++)   cout<<val[j+n]<<" ";
    return 0;
}