杭高OI20190125 （genies出题）

/*
当一个人先从自己的内心开始奋斗，他就开始迈向了成功
——genies (朝阳的二愣子)
*/

HGOI寒假赛第一场，欢迎来自各种学校的各式各样的巨老233333

感觉自己好渺小。还是NOIP （pj）的模拟题吧，也有AK的，不过我是下划线开头，所以我来讲咯。

踩了std，（还有xyc大佬踩了标程！他比我快！），感觉还是挺水的。

自己还是要提高（下午讲了数论，相信高一党没怎么听懂23333）

T1 发射站（fsz）

solution：就是单调栈的题目，由于是数据听说比较强然后打了手写栈！结果就不说了吧（n方tm都能过！）

思路挺简单就是第一遍找第一个右侧比他高的，能量给高的（在弹栈的时候），显然需要维护一个h单调不增的栈，每次插入一个元素的时候弹出元素，

并把弹出元素的能量v累加到即将插入的元素i上，然后正反搞2遍，扫一遍ans就出来了！（我是不会告诉你我这道题打了1h10min的！）

code:

# include<bits/stdc++.h>
# define int long long
using namespace std;
const int N=1e6+;
struct rec{
    int h,v;
}a[N];
int n,ans[N];
inline int read()
{
    int X=,w=; char c=;
    while(c<''||c>'') {w|=c=='-';c=getchar();}
    while(c>=''&&c<='') X=(X<<)+(X<<)+(c^),c=getchar();
    return w?-X:X;
}
struct sta{
    int Top;  rec s[N];
    sta(){Top=;}
    bool empty() {return (Top==);}
    void push(rec x){s[++Top]=x;}
    void pop(){ Top--;}
    void clear(){ Top=;};
    rec top(){return s[Top];}
}s;
signed main()
{
    n=read();
    for (int i=;i<=n;i++)
        a[i].h=read(),a[i].v=read();
    for (int i=;i<=n;i++) {
        if (s.empty()) { s.push(a[i]);  continue; }
        while (!s.empty()&&s.top().h<a[i].h) {
            ans[i]+=s.top().v;
            s.pop();
        }
        s.push(a[i]);
    }
    s.clear();
    for (int i=n;i>=;i--) {
        if (s.empty()) { s.push(a[i]);  continue; }
        while (!s.empty()&&s.top().h<a[i].h) {
            ans[i]+=s.top().v;
            s.pop();
        }
        s.push(a[i]);
    }
    int Ans=;
    for (int i=;i<=n;i++) Ans=max(Ans,ans[i]);
    printf("%lld\n",Ans);
    return ;
}

T2  绝对值（abs）

solution:思路也是显然的；需要的时间复杂度是O(T * ⁴√x )

考虑一个数y合法（每个质因数出现2次）那么有 √y 每个质因数出现1次！

知道这个结论，对于每一个x，我们在线在（下取整）√x左右偏移step个单位，构造出x‘=（√x+step）²然后在可行的情况下

最小化| x'² - x |就行，但是需要考虑一个边界问题，什么时候单调，由于√x是下取整，那么√x和√x+1是一对，

如此类推√x-1和√x+2是一对，则有√x-step和√x+step+1是一对，step∈[0,+∞)，这样就有单调性！

还有那个筛素数实际上只要筛到⁴√x 就行了，就是1e5！

# include <bits/stdc++.h>
# define int long long
using namespace std;
const int N=1e5+;
bool pr[N];
int last[N];
vector<int>a;
inline int read()
{
    int X=,w=; char c=;
    while(c<''||c>'') {w|=c=='-';c=getchar();}
    while(c>=''&&c<='') X=(X<<)+(X<<)+(c^),c=getchar();
    return w?-X:X;
}
void getprime(int Lim)
{
    memset(pr,true,sizeof(pr));
    pr[]=pr[]=false;
    for (int i=;i<=Lim;i++) {
        if (!pr[i]) continue;
        a.push_back(i);
        for (int j=i+i;j<=Lim;j+=i)
        pr[j]=false;
    }
}
bool check(int x)
{
    if (x<) return false;
    int p=,cnt;
    for (;;){
        int nowprime=a[p];
        if (nowprime>x||p==a.size()-) break;
        cnt=;
        while (x%nowprime==) cnt++,x/=nowprime;
        if (cnt>) return false;
        p++;
    }
    return true;
}
# define SQR(x) ((x)*(x))
int work(int x) {
    int base=sqrt(x);
    int step=;
    while (true) {
        bool g1=check(base+step+);
        bool g2=check(base-step);
        if (g1&&g2) {
            if (abs(x-SQR(base+step+))<abs(x-SQR(base-step))) return base+step+;
            else return base-step;
        }
        else if (g1) return base+step+;
        else if (g2) return base-step;
        step++;
    }
}
void write(int x)
{
    if (x>) write(x/);
    putchar(''+x%);
}
void writeln(int x)
{
    write(x);   putchar('\n');
}
signed main()
{
    getprime(1e5);
    int T=read();
    while (T--) {
        int x=read();
        writeln(abs(x-SQR(work(x))));
    }
    return ;
}

T3  独特的路径（path）

solution：一开始看成状压orz，怎么存不下状态鸭（滑稽），后来发现看错题了。搜索题！

首先需要知道这么一个东西，如果走到这个点(x,y)用掉了c种颜色，然而要走到(n,m)才算成功，

那么之后（从(x,y)走到(n,m)）至少还需要用掉 n-(x-1)+m-(y-1)-1=n-x+m-y+1 种颜色

特殊的，从(1,1)走到(n,m)需要经过n+m-1个格子.

发现这一条性质30%的分数就有了，开局特判k和n,m的关系。若(n+m-1>k)输出0

然后搜索剪枝，顺序需要保证左上角矩阵出现过的元素不能在此格子填写，所以左上角必须搜完，采用从左往右，从上到下的形式搜！

剪枝：

• 可行性：到(x,y)看剩下的颜色够不够即前面用掉c种，那么若(n-x+m-y+1)>k-c那么直接不可以。
• 对偶性：.在填某一个格子时，如果某些颜色在之前没有使用过，那么他们的情况数都是相同的。（如果之前用过就不一定了!）

不要忘记膜

code:

# include <bits/stdc++.h>
# define int long long
using namespace std;
const int N=1e3+;
const int mo=1e9+;
const int BIT=;
int mp[N][N],f[N][N],num[BIT];
int n,m,k;
inline int read()
{
    int X=,w=; char c=;
    while(c<''||c>'') {w|=c=='-';c=getchar();}
    while(c>=''&&c<='') X=(X<<)+(X<<)+(c^),c=getchar();
    return w?-X:X;
}
# define lowbit(x) ((x)&(-x))
# define bit_place(x) (trunc(log(x+0.5)/log()))
int bit_count(int x)
{
    int cc=;
    for (int i=x;i;i-=lowbit(i)) cc++;
    return cc;
}
int dfs(int x,int y)
{
    if (y>m) x=x+,y=;
    if (x>n) return ;
    f[x][y]=f[x-][y]|f[x][y-];
    if (n-x+m-y+>k-bit_count(f[x][y])) return ;
    int qwq=-,sum=;
    for (int base=(~f[x][y])&((<<k)-);base;base-=lowbit(base)) {
        int d=lowbit(base);
        int col=bit_place(d)+;
        if (mp[x][y]==||mp[x][y]==col) {
            int record=f[x][y];
            f[x][y]=f[x][y]|d;
            num[col]++;
            if (num[col]==) {
                if (qwq==-) qwq=dfs(x,y+);
                sum=(sum+qwq)%mo;
            } else sum=(sum+dfs(x,y+))%mo;
            num[col]--;
            f[x][y]=record;
        }
    }
    return sum%mo;
}
signed main()
{
    n=read();m=read();k=read();
    if (n+m>k+) { puts(""); return ;}
    for (int i=;i<=n;i++)
     for (int j=;j<=m;j++)
      mp[i][j]=read(),num[mp[i][j]]++;
    memset(f,,sizeof(f));
    int tmp=dfs(,);
    printf("%lld\n",tmp%mo);
    return ;
}