2019年杭电暑期多校（第四场）

1007 Just an Old Puzzle（n数码+归并求逆序数）

题意
给定一个4*4的矩阵，按照8数码一样的移动方式，问能否在120步内移动到目标状态。
思路
虽然我不知道怎么证明，反正如果两个状态能够互相到达，那么所需步数最多只需要46步。那么只需要求两个状态能否互相到达就好了。

n*m的数码问题有一个结论：
1.假如m是奇数，那么上下交换会改变（m-1）也就是偶数次逆序数，左右交换（空格和左右交换）不改变逆序数，因此逆序数的奇偶性不变，此时两状态的奇偶性一致即有解

2.假如m是偶数，上下交换会改变奇数次逆序数，左右交换不改变逆序数，因此逆序数奇偶性会因上下交换而改变，此时逆序数之差和两个局面下空格所在行数之差
的奇偶性相同即有解。

但是，这里所指的逆序数是不计算0的！！！！
也就是除空格外，剩下数的逆序数之差才是我们要求的东西，网上没有一篇博客讲到这个，还有很多博客讲的结论根本就是错的。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cmath>
#define lson node<<1
#define rson node<<1|1
using namespace std;
typedef long long ll;
const int maxn = 20;
const int mod = 1e9+7;
const ll inf=1e18-1;
int a[maxn],temp[maxn];
long long sum=0;
void merge(int l,int r,int m){
    int i = l, j = m + 1,k = l;
    while(i<=m&&j<=r){
        if(a[i] > a[j]){
            sum += m - i + 1;
            temp[k++] = a[j++];
        }else{
            temp[k++] = a[i++];
        }
    }
    while(i<=m)
        temp[k++] = a[i++];
    while(j<=r)
        temp[k++] = a[j++];
    for(i = l;i<=r;i++)
        a[i] = temp[i];
}
void mergesort(int l,int r){
    if(l<r){
        int m = (l + r) / 2;
        mergesort(l,m);
        mergesort(m+1,r);
        merge(l,r,m);
    }
}

int main(){
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int st;
        int cnt=0;
        for(int i=1;i<=4;i++)
        {
            for(int j=1;j<=4;j++)
            {
                int c;
                scanf("%d",&c);
                if(c!=0)
                    a[++cnt]=c;
                else
                    st=4-i;
            }

        }
        sum=0;
        mergesort(1,15);
        if(st%2==sum%2)
            printf("Yes\n");
        else
            printf("No\n");

    }
}

1008 K-th Closest Distance(主席树+二分)

题意
求$[L，R]$内$|p-a[i]|$的第k小
题解
第k小肯定是主席树了，但是这里的绝对值很麻烦，看完题解才明白是个很巧妙的方法。我们二分答案ans，对于$[p-ans,p+ans]$的值区间求区间和，如果数量大于等于k说明第k小一定在这个区间内，然后可以缩小ans继续查找就能得到答案。
主席树的板子错了改了一天bug，真的没想到错掉的板子还能过洛谷的模板题。

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

const int maxn = 1e5 + 20;
int lson[maxn * 30], rson[maxn * 30], tree[maxn * 30];
int a[maxn], ha[maxn];
int T[maxn];
int n, q, len, tot;


void init()
{
    tot = 0;
    sort(ha + 1, ha + 1 + n);
    len = unique(ha + 1, ha + 1 + n) - ha - 1;
}

int gethash(int x)
{
   return lower_bound(ha + 1, ha + 1 + len, x) - ha;
}

int build(int l,int r)
{
    int rt = tot++;
    tree[rt] = 0;
    if (l!=r)
    {
        int mid = (l + r) >> 1;
        lson[rt] = build(l, mid);
        rson[rt] = build(mid + 1, r);
    }
    return rt;
}

int update(int rt,int pos,int val)
{
    int newroot = tot++;
    int temp = newroot;
    tree[newroot] = tree[rt] + val;        //更新区间和
    int l = 1, r = len;
    while (l<r)                                 //这里迭代更新比递归快一点
    {
        int mid = (l + r) >> 1;
        if (pos<=mid)
        {     
            lson[newroot] = tot++;
            rson[newroot] = rson[rt];
            newroot = lson[newroot];
            rt = lson[rt];
            r = mid;
        }
        else
        {
            rson[newroot] = tot++;
            lson[newroot] = lson[rt];
            newroot = rson[newroot];
            rt = rson[rt];
            l = mid + 1;
        }
        tree[newroot] = tree[rt] + val;
    }
    return temp;
}

int query(int rt,int l,int r,int ql,int qr)
{
    if(ql<=l&&r<=qr)
    {
        return tree[rt];
    }
    int mid = (l + r) >> 1;
    int ans = 0;
    if(ql<=mid)
    {
        ans += query(lson[rt], l, mid, ql, qr);
    }
    if(qr>mid)
    {
        ans += query(rson[rt], mid + 1, r, ql, qr);
    }
    return ans;
}


bool check(int st,int end,int temp,int p,int k)
{
    int l = lower_bound(ha + 1, ha + 1 + n, p - temp)-ha;
    int r = upper_bound(ha + 1, ha + 1 + n, p + temp)-ha-1;
    if(l>r)
        return false;
    int hh = query(T[end], 1, len, l, r) ;
    int hhh= query(T[st - 1], 1, len, l, r);
    if(query(T[end],1,len,l,r)-query(T[st-1],1,len,l,r)>=k)
    {
        return true;
    }
    else
    {
        return false;
    }
}
int main()
{
    int t;
    scanf("%d", &t);
    while(t--){
        scanf("%d%d", &n, &q);
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
            ha[i] = a[i];
        }
        init();
        T[0] = build(1, len);
        for(int i=1;i<=n;i++)
        {
            T[i] = update(T[i - 1], gethash(a[i]), 1);
        }
        // for (int i = 1; i <= n; i++)
        // {
        //    // cout << gethash(a[i]) << endl;
        //     cout <<"ls="<< lson[T[i]] <<"  rs="<<rson[T[i]]<<" -  "<<tree[T[i]]<<endl;
        // }
        
        int x=0,l,r,p,k;
        for (int i = 1; i <= q;i++)
        {
            scanf("%d%d%d%d", &l, &r, &p, &k);
            l = l ^ x;
            r = r ^ x;
            p = p ^ x;
            k = k ^ x;
            int L = 0, R = 1e6;
            while(L<=R)
            {
                int mid = (L + R) >> 1;
                if(check(l,r,mid,p,k))
                {
                    R = mid - 1;
                    x = mid;
                }
                else
                {
                    L = mid + 1;
                }               
            }
            printf("%d\n",x);         
        }
    }
}

1010 Minimal Power of Prime（素数筛+思维）

题意
求1e18以内的n的质因子分解的最小次幂
思路
看到这题就懵了啊，1e18的大小，还有5e4的t，结果才知道原来没那么复杂，先预处理出1e4内的素数（大概1e3个），然后对n先进行质因子分解，记录一下最小值，然后如果n还是大于1，那么就意味着，这个数还可以被大于1e4的质数分解，而这个质数的幂次最多是4，因为1e4的5次方已经超过1e18了。
设p，q为大于1e4的质数
则$n=p^4,p^3,p^2,p^2\ast q^2$除了这几种情况当然还有别的，但是那些情况的答案都为1了。
所以只需要对n求4，3，2次方根，看看是否存在正整数解，这样就可以推出是否是上面那几种情况了。对于开三次方根，用pow有精度损失，所以要用二分。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cmath>
#define lson node<<1
#define rson node<<1|1
using namespace std;
typedef long long ll;


const int maxn = 1e4;
const ll inf=(ll)(2e5)*(ll)(1e9)+900;

inline int min(int a,int b)
{
    return a<b?a:b;
}


int prime[maxn+10];
void getprime(){
    memset(prime,0,sizeof(prime));
    for(int i=2;i<=maxn;i++){
        if(!prime[i])prime[++prime[0]]=i;
        for(int j=1;j<=prime[0]&&prime[j]<=maxn/i;j++){
            prime[prime[j]*i]=1;
            if(i%prime[j]==0) break;
        }
    }
}
int find(ll n)          //求是否是某个数的三次方
{
    int l=maxn;
    int r=maxn*100;     //x在1e18以内所以最多是1e6的三次方
    while(l<=r)
    {
        int mid=l+r>>1;
        ll t=1ll*mid*mid*mid;
        if(t<n)
            l=mid+1;
        if(t>n)
            r=mid-1;
        if(t==n)
            return 1;
    }
    return 0;

}
int slove(ll n)
{
    int ans=64;
    for(int i=1;i<=prime[0]&&prime[i]<=n;i++)
    {
        if(n%prime[i]==0)
        {
            int t=0;
            while(n%prime[i]==0)
            {
                n/=prime[i];
                t++;
            }
            ans=min(ans,t);
        }
    }
    int u1=sqrt(n);
    int u2=sqrt(u1);
    if(n==1)
    {
        return ans;
    }
    else if(1ll*u2*u2*u2*u2==n)
    {
        ans=min(ans,4);
        return ans;
    }
    else if(find(n))
    {
        ans=min(ans,3);
        return ans;
    }
    else if(1ll*u1*u1==n)
    {
        ans=min(ans,2);
        return ans;
    }
    else
    {
        return 1;
    }
}


int main(){
    getprime();
    int t;
    scanf("%d",&t);
    while(t--)
    {
        ll n;
        scanf("%lld",&n);
        printf("%d\n",slove(n));
    }

}