qbxt Day 6 搜索+乱搞+差分约束

？？=乱搞…………

T1：

对于100%的数据，n<=10^9;

对于某个数
t | 12;
显然 ： t=2^x * 3^y;
其中 0<=x<=2, 0<=y<=1;
所以，12的因子个数为（2+1）*（1+1）；

而对于 2^3 * 3^2 与 2^2 * 3^3 因子个数相同；
但前面的小，由此，我们需要保证2的幂>= 3的幂；

即小的幂>= 大的幂；

搜索就可以了~；

因为指数是log级别的，我们枚举指数，爆搜即可

收获：
1.因子个数的公式；
2.搜索的新姿势；

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
ll n,ans,maxn=1;
ll is_p[]={0,2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53};
void dfs(ll x,ll sum,ll tot,ll limit)
{
    if(sum>n || x>12) return;
    if((tot>ans) || (tot==ans && sum<maxn))
    ans=tot,maxn=sum;
    for(ll i=1;sum*is_p[x]<=n && i<=limit;i++)
    {
        sum*=is_p[x];
        dfs(x+1,sum,tot*(i+1),i);
    }
}
void solve()
{
    cin>>n;
    if(n==1) {cout<<1<<endl;return;}
    dfs(1,1,1,1001);
    cout<<maxn;
}
int main()
{
    solve();
    return 0;
}

注意第17行和第18行不能合为dfs(x+1,sum* is_p[x], tot*(i+1), i);

因为对于每一层x的sum值必须递增，不能回溯，否则会跳不出循环，而且对于
不同层的x，sum值是会回溯到上一状态的；

如果写成这个样子，会造成无法乘多个is_p[x]的情况；

强化了我对于搜索的理解，其实dfs与bfs是相似的，都有状态；

有时同一层的状态需要不断改变，而有时不会改变，注意以后做题把握好搜索的目的，避免这种死循环的出现；

T2：

好吧，我语文不好；

读了半年^n 才明白是什么意思；

我的思路：先topsort，再记录各种树的形状，但形状不会搞，所以弃疗了；

正解：topsort，对整棵树hash…………

我怎么没想到hash！！！！！！

树怎么还可以hash！！！！！！

map怎么还可以映射vector啊！！！！！！！

呜呜呜呜呜，智商不够，见识不高啊；

思路对了，代码还是“很好写”的；

注意最后的字典序的输出；

我们只需要处理其中一组解，把它转化为最小的字典序即可；

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
const int MAXN=200001;
map<vector<int>,int>s;// map的新姿势Orz;  
vector<int>E[MAXN];
int cnt,n,ans[MAXN],vis[MAXN];
int dfs(int x)
{
    vector<int>u;
    for(int i=0;i<E[x].size();i++)
    {
        int v=E[x][i];
        u.push_back(dfs(v));
    }
    sort(u.begin(),u.end());//避免形状相同的子树映射值不同； 
    if(!s[u]) s[u]=++cnt;//随便赋个值; 
    ans[x]=s[u];
    return ans[x];
}
void solve()
{
    cin>>n;
    for(int i=2;i<=n;i++)
    {
        int x;
        scanf("%d",&x);
        E[x].push_back(i); //已经知道每个点的父亲，所以单向边已经够了； 
    }
    dfs(1),cnt=0;
    for(int i=1;i<=n;i++)
    {
        if(!vis[ans[i]]) vis[ans[i]]=++cnt;//转化为字典序最小的一组解； 
        ans[i]=vis[ans[i]];
    }
    for(int i=1;i<=n;i++) cout<<ans[i]<<" ";
    return;
}
int main()
{
    solve();
    return 0;
}

差分约束，建图拓扑排序；

若 Rxy=1, 则从点x向y+n建边；
若Rxy=0, 则从点y+n向x建边；

如果图存在环，则无解；

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int MAXN = 2001;
int fst[MAXN],nxt[MAXN],ru[MAXN<<1],dis[MAXN];
char s[MAXN];
int tot,n;
bool vis[MAXN];


struct hh
{
    int from,to,cost;
}ma[2000001];


void build(int f,int t,int c)
{
    tot++;
    ma[tot]=(hh){f,t,c};
    nxt[tot]=fst[f];
    fst[f]=tot;
    return;
}

void topsort()
{
    queue<int>q;
    for(int i=1;i<=(n<<1);i++) if(!ru[i]) q.push(i),vis[i]=1;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(int i = fst[x];i;i = nxt[i])
        {
            int v = ma[i].to;
            ru[v]--,vis[v]=1;
            dis[v]=max(dis[x]+ma[i].cost,dis[v]);
            if(!ru[v]) q.push(v);
        }
    }
    return;
}


void solve()
{
    scanf("%d",&n);
    for(int i = 1;i <= n;i ++)
    {
        scanf("%s",s+1);
        for(int j = 1;j <= n;j ++ )
            if(s[j] == '1') 
                build(i,j+n,1),ru[j+n] ++;
            else 
                build(j+n,i,1),ru[i]++;
    }
    topsort();
    for(int i = 1;i <= (n<<1) ;i++)//判环，如果有点没有被访问过，说明在环上； 
        if(!vis[i]) {printf("NO\n");return;}
    printf("YES\n");
    for(int i = 1;i <= n;i ++) printf("%d ",dis[i]);
    printf("\n");
    for(int i = n+1 ;i <= (n<<1);i ++) printf("%d ",dis[i]);
    return;
}


int main()
{
    solve();
    fclose(stdin);
    fclose(stdout);
    return 0;
}