真·奥义·随意的hu测（18.2.28）

最新推荐文章于 2023-02-26 20:58:43 发布
最新推荐文章于 2023-02-26 20:58:43 发布
阅读量215 收藏 1
点赞数
分类专栏： dp 图论 拓扑 线段树 日常hu测 文章标签： 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu_tongtong/article/details/79403253
版权
dp 同时被 3 个专栏收录
218 篇文章 2 订阅
订阅专栏
图论
64 篇文章 0 订阅
订阅专栏
日常hu测
61 篇文章 0 订阅
订阅专栏

今天的hu测真心随意，也没有好好写代码

T1，T3真心难
大家就当看着玩吧

T1

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

题解：
对于一个良好数列，我们考虑按数值从小到大加入数列中的元素

若当前加入的元素中最大值为x，若数列中一个区间内的数大于x，则那些位置出现空缺，且空缺两端都是x，我们称这类区域为待补区域

对于一个良好数列，在上述加入元素过程中出现过的任一数列，我们称之为准良好数列

由准良好数列从小到大排序后形成的数列，我们称之为准优秀数列

我们按照上面所说的插入数的过程进行动态规划
定义f[i][j][p][q]，表示当前数列中最大值为i，长度为j，待补区域数为p，通过重排可形成q个准良好数列的准优秀数列个数

可以用滚动数组优化空间

#include<cstdio>
#define ll long long

using namespace std;

const int N=1000005;
const int p=1e9+7;
int dp[2][102][102][102];
bool vis[2][102][102][102];
int q[2][N][3],wei[2];
int n,m,K,g[102][102];
int ans=0;

int main() {
    int i,j,k,l,s,t;
    scanf("%d%d%d",&n,&m,&K);

    g[0][0]=1;
    for (j=1;j<=n;j++)
        for (i=0;i<=n;i++)
            for (k=0;k<=i;k++) 
            {
                g[i][j]+=g[k][j-1];
                if (g[i][j]>=p) g[i][j]-=p;
            }

    for (i=1;i<=n;i++) 
    {
        wei[0]++;
        q[0][wei[0]][0]=i;
        q[0][wei[0]][1]=i;
        q[0][wei[0]][2]=1;
        dp[0][i][i][1]=1;
    }

    for (i=0;i<m;i++) 
    {
        int o=(i&1);
        int now=o^1;
        for (s=1;s<=wei[now];s++)
            vis[now][q[now][s][0]][q[now][s][1]][q[now][s][2]]=0;
        wei[now]=0;
        for (s=1;s<=wei[o];s++) 
        {
            j=q[o][s][0];
            k=q[o][s][1];
            l=q[o][s][2];
            if (k) 
            {
                for (t=0;j+k+t<=n && l*g[t][k]<=K;t++) 
                {
                    if (!vis[now][j+k+t][t][l*g[t][k]])
                    {
                        vis[now][j+k+t][t][l*g[t][k]]=1;
                        dp[now][j+k+t][t][l*g[t][k]]=0;
                        wei[now]++;
                        q[now][wei[now]][0]=j+k+t;
                        q[now][wei[now]][1]=t;
                        q[now][wei[now]][2]=l*g[t][k];
                    }
                    dp[now][j+k+t][t][l*g[t][k]]+=dp[o][j][k][l];
                    if (dp[now][j+k+t][t][l*g[t][k]]>=p)
                        dp[now][j+k+t][t][l*g[t][k]]-=p;
                }
            }
            else
            {
                ans+=(((ll)(m-i)*dp[o][j][k][l])%p);
                if (ans>p) ans-=p;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

T2

T3

这里写图片描述

这里写图片描述
这里写图片描述

题解：
先将坐标离散化。
直接求有多少矩形与(x1,y1,x2,y2)有公共点比较难实现，可以用总矩形数
减去与(x1,y1,x2,y2)没有公共点的矩形(a,b,c,d)的数量

  • 若 c＜x1，没有公共点
  • 若 d＜y1，没有公共点
  • 若 a＞x2，没有公共点
  • 若 b＞y2，没有公共点

这些数量都可以用线段树来维护
但有些与(x1,y1,x2,y2)没有公共点的矩形被计算了两次

  • c＜x1，且 d＜y1
  • c＜x1，且 b＞y2
  • a＞x2，且 d＜y1
  • a＞x2，且 b＞y2

维护每一个值都相当于是要支持以下两种操作：

  • 加入一个点
  • 求一个矩形范围内点的个数

这些操作可以用树状数组套线段树实现，但会超出内存限制

那么可以用分块的思想：
先对每个横坐标建立一棵线段树记录横坐标等于这个值的点的纵坐标有哪些，对横坐标分块，
再对每个块建立一棵线段树记录横坐标在这个块范围内的点的纵坐标有哪些
修改就修改横坐标的线段树和对应块的线段树
查询时整块的部分在块的线段树上查询，其他部分在横坐标的线段树上查询

这样的时间复杂度是O(m sqrt(m) log(m)) ，但还是有可能会超出时间限制

既然可以分一次块，那就可以继续分，对已经分出的那些块再进行一次分块，
同样对每一个由块组成的大块也建立一棵线段树
修改时要修改大块的线段树、小块的线段树、横坐标的线段树
查询时先找完整的大块，再在其他部分找完整的小块，剩下的部分就每一个横坐标单独计算

这样就可以通过所有测试数据了

//std

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>
using namespace std;
const int N = 100500;
const int MN = 200500;
const int M = 18005000;
int m;
struct Rec
{
    int a,b,c,d;
};
struct Opt
{
    Rec rec;
    int opt;
}xu[N];
int insc[N];
int xux[MN],xuy[MN];
int size;
struct Node
{
    Node *lson,*rson;
    int val;
}tree[M];
int cc;
struct Tree
{
    Node *point[MN];
    Node *lumpx[MN];
    Node *lump[MN];
}zs,ys,zx,yx;
char getopt()
{
    char ch=getchar();
    while(ch<'A' || ch>'Z')
        ch=getchar();
    return ch;
}
int getint()
{
    int res=0;
    char ch=getchar();
    while((ch<'0' || ch>'9') && ch!='-')
        ch=getchar();
    bool fan=0;
    if(ch=='-')
    {
        fan=1;
        ch=getchar();
    }
    while('0'<=ch && ch<='9')
    {
        res=res*10+ch-'0';
        ch=getchar();
    }
    if(fan)
        res=-res;
    return res;
}
void getrec(Rec &x)
{
    x.a=getint();
    x.b=getint();
    x.c=getint();
    x.d=getint();
}
void Discr(int x[])
{
    sort(x+1,x+x[0]+1);
    int t=0,i;
    for(i=1;i<=x[0];i++)
    {
        x[++t]=x[i];
        while(i<x[0] && x[i]==x[i+1])
            i++;
    }
    x[0]=t;
}
int NoLess(int x[],int l,int r,int z)
{
    if(l==r)
        return l;
    int mid=(l+r)/2;
    if(x[mid]>=z)
        return NoLess(x,l,mid,z);
    return NoLess(x,mid+1,r,z);
}
int NoMore(int x[],int l,int r,int z)
{
    if(l==r)
        return l;
    int mid=(l+r+1)/2;
    if(x[mid]<=z)
        return NoMore(x,mid,r,z);
    return NoMore(x,l,mid-1,z);
}
void Discrec(Rec &x)
{
    x.a=NoLess(xux,1,xux[0]+1,x.a);
    x.b=NoLess(xuy,1,xuy[0]+1,x.b);
    x.c=NoMore(xux,0,xux[0],x.c);
    x.d=NoMore(xuy,0,xuy[0],x.d);
}
void GetData()
{
    int i;
    m=getint();
    for(i=1;i<=m;i++)
    {
        char ch=getopt();
        if(ch=='I')
        {
            xu[i].opt=1;
            getrec(xu[i].rec);
            xux[++xux[0]]=xu[i].rec.a;
            xux[++xux[0]]=xu[i].rec.c;
            xuy[++xuy[0]]=xu[i].rec.b;
            xuy[++xuy[0]]=xu[i].rec.d;
            insc[++insc[0]]=i;
        }
        else if(ch=='D')
        {
            xu[i].opt=2;
            xu[i].rec=xu[insc[getint()]].rec;
        }
        else
        {
            xu[i].opt=3;
            getrec(xu[i].rec);
        }
    }
    Discr(xux);
    Discr(xuy);
    for(i=1;i<=m;i++)
        Discrec(xu[i].rec);
    for(size=1;size*size*size<=xux[0];size++);
}
Node *New()
{
    cc++;
    return tree+cc;
}
void Change(Tree &t,int x,int y,int v)
{
    int l,r;
    Node *now;
    if(!t.point[x])
        t.point[x]=New();
    now=t.point[x];
    now->val+=v;
    l=1;r=xuy[0];
    while(l<r)
    {
        int mid=(l+r)/2;
        if(y<=mid)
        {
            if(!now->lson)
                now->lson=New();
            now=now->lson;
            r=mid;
        }
        else
        {
            if(!now->rson)
                now->rson=New();
            now=now->rson;
            l=mid+1;
        }
        now->val+=v;
    }
    x/=size;
    if(!t.lumpx[x])
        t.lumpx[x]=New();
    now=t.lumpx[x];
    now->val+=v;
    l=1;r=xuy[0];
    while(l<r)
    {
        int mid=(l+r)/2;
        if(y<=mid)
        {
            if(!now->lson)
                now->lson=New();
            now=now->lson;
            r=mid;
        }
        else
        {
            if(!now->rson)
                now->rson=New();
            now=now->rson;
            l=mid+1;
        }
        now->val+=v;
    }
    x/=size;
    if(!t.lump[x])
        t.lump[x]=New();
    now=t.lump[x];
    now->val+=v;
    l=1;r=xuy[0];
    while(l<r)
    {
        int mid=(l+r)/2;
        if(y<=mid)
        {
            if(!now->lson)
                now->lson=New();
            now=now->lson;
            r=mid;
        }
        else
        {
            if(!now->rson)
                now->rson=New();
            now=now->rson;
            l=mid+1;
        }
        now->val+=v;
    }
}
void AddRec(Rec &x)
{
    Change(zs,x.a,x.b,1);
    Change(zx,x.c,x.b,1);
    Change(ys,x.a,x.d,1);
    Change(yx,x.c,x.d,1);
}
void DelRec(Rec &x)
{
    Change(zs,x.a,x.b,-1);
    Change(zx,x.c,x.b,-1);
    Change(ys,x.a,x.d,-1);
    Change(yx,x.c,x.d,-1);
}
int FindX(Node *x,int zl,int zr)
{
    if(zr==xuy[0])
    {
        if(x)
            return x->val;
        return 0;
    }
    zr++;   
    int res=0;
    int l=1,r=xuy[0];
    while(l<r && x)
    {
        int mid=(l+r)/2;
        if(zr<=mid)
        {
            x=x->lson;
            r=mid;
        }   
        else
        {
            if(x->lson)
                res+=x->lson->val;
            x=x->rson;
            l=mid+1;
        }   
    }
    return res; 
}
int Find(Tree &t,int a,int b,int c,int d)
{
    if(a>b || c>d)
        return 0;
    int ax=a/size;
    int bx=b/size;
    int axx=ax/size;
    int bxx=bx/size;
    int i;
    int res=0;
    if(bxx-axx>1)
    {
        for(i=axx+1;i<bxx;i++)
            res+=FindX(t.lump[i],c,d);
        for(i=ax+1;i/size==axx;i++)
            res+=FindX(t.lumpx[i],c,d);
        for(i=a;i/size==ax;i++)
            res+=FindX(t.point[i],c,d);
        for(i=bx-1;i/size==bxx;i--)
            res+=FindX(t.lumpx[i],c,d);
        for(i=b;i/size==bx;i--)
            res+=FindX(t.point[i],c,d);
    }
    else
    {
        if(bx-ax>1)
        {
            for(i=ax+1;i<bx;i++)
                res+=FindX(t.lumpx[i],c,d);
            for(i=a;i/size==ax;i++)
                res+=FindX(t.point[i],c,d);
            for(i=b;i/size==bx;i--)
                res+=FindX(t.point[i],c,d);
        }
        else
        {
            for(i=a;i<=b;i++)
                res+=FindX(t.point[i],c,d);
        }
    }
    return res;
}
void FindRec(Rec &x)
{
    int res=0;
    res+=Find(zs,1,x.c,1,x.d);
    res-=Find(zx,1,x.a-1,1,x.d);
    res-=Find(yx,x.a,xux[0],1,x.b-1);
    res+=Find(ys,x.c+1,xux[0],1,x.b-1);
    printf("%d\n",res);
}
void DoIt()
{
    int i;
    for(i=1;i<=m;i++)
    {
        if(xu[i].opt==1)
            AddRec(xu[i].rec);
        else if(xu[i].opt==2)
            DelRec(xu[i].rec);
        else
            FindRec(xu[i].rec);
    }
}
int main()
{
    freopen("rec.in","r",stdin);
    freopen("rec.out","w",stdout);
    GetData();
    DoIt();
    return 0;
}
Coco_T_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
端午节习俗中的养生奥义PPT.ppt
07-07
端午节习俗中的养生奥义PPT.ppt
真·奥义·随意的hu测 T2.线段（拓扑）
Coco_T的博客
02-28 198
题外话： 这道题其实已经想到正解了，但是在维护答案的细节上出了问题 看来还是考虑的不全面，不能从特殊情况推出一般的规律 还是不能偷懒，一定要用多样化的数据测试自己算法 也算是一个教训吧，dada们比你高明到不知哪里去了，力求完美吧 分析： 直觉是一个图论 xxx与yyy相交：a[x]&lt;b[y]a[x]&lt;b[y]a[x]a[y]&gt;b[x]a[y]&gt;...
自动化测试核心奥义
邢超的博客
04-15 368
今天我们不谈具体技术实现，只谈自动化测试的核心思想（针对Web的UI自动化测试） 很多人一提起自动化测试，就会提起Selenium、Robotframework，Unittest，Pytest，TestNG等框架，可是这样说，是不准确的，其实自动这里有两类框架，一类是像Selenium这样的自动化的操纵框架，另一类像后面几个这样是书写时候的框架（也就是约定测试类，函数，然后看最终有多少个测试用例...
Promise奥义
iiiiiiiice的博客
02-26 84
回掉地狱===函数瀑布？promise由来、状态、方法
【C语言】指针的真正奥义！！！
helinliupi的博客
07-19 9521
1.可以看出，普通函数里换传递的值改变不了main函数里的变量的值2.用函数传递地址，用指针接收可以在函数里改变main函数里的变量的值，这也是最重要的指针用法。！！httpshttpshttpshttps。
淘宝螺旋成败的终极奥义原来是。。。.zip
12-15
淘宝螺旋成败的终极奥义原来是。。。.zip
淘宝螺旋成败的终极奥义原来是。。。.doc
09-11
淘宝螺旋成败的终极奥义原来是。。。.doc
Matlab图形的编辑(含绘图修改的奥义[收集].pdf
10-11
Matlab图形的编辑(含绘图修改的奥义[收集].pdf
这就是用户运营的「终极奥义」
02-25
运营的所有行当里，用户运营是最复杂的。在所有林林总总的用户运营里，大多数人只是管管微信群，有些严格来说是客服，有的负责写App推送，有的要做活动。甚至某些UGC平台的小编、直播平台的审核员，也叫用户运营。...
poj1737 Connected Graph（n点无向连通图）
Coco_T的博客
03-15 3961
题目链接 题目描述： 给出n个点，求n个点的无向连通图 分析： 巨坑啊 经典题目，有两种方法： 总方案数-不合法方案 nnn个点的完全图有C(n,2)=n(n−1)2C(n,2)=n(n−1)2C(n,2)={n(n-1) \over 2}条边，显然就有2C(n,2)2C(n,2)2^{C(n,2)}种子图（枚举每条边是否选择） 设f[i]f[i]f[i]表示每个点都和点1相连...
当图变成了一棵树（纠结的生成树）
Coco_T的博客
10-11 3791
最小生成树 经典算法Kruskal算法 int cmp(const node &amp;c,const node &amp;d) { return c.z&lt;d.z; } int find(int x) //路径压缩（没有按秩合并）的并查集 { if (fa[x]!=x) fa[x]=find(fa[x]); return f...
网络流（多样的建模）
Coco_T的博客
10-12 2475
yhzq的总结是非常好的： 网络流总结 然而博主也不是一个只会复制链接的人，还是要有一点自己的感悟的 网络流问题最重要的就是建模和模型转换，下面就给出一些 经典模型 一、最大流 多源多汇问题 源有多个，汇也有多个，流可以从任意源流出，最终可以流向任意汇， 总流量等于所有源流出的总流量（所有汇流入的总流量） 解：加一个超级源点S，和超级汇点T， 从S向每一个源点引一条...
强连通分量SCC（Tarjan）
Coco_T的博客
06-13 943
什么叫强连通分量呢~ 有向图强连通分量在有向图G中， 如果两个顶点vi,vj间(vi>vj)有一条从vi到vj的有向路径，同时还有一条从vj到vi的有向路径，则称两个顶点强连通(strongly connected)。 如果有向图G的每两个顶点都强连通，称G是一个强连通图。 有向图的极大强连通子图，称为强连通分量(strongly connected components)。
11.5 T1.attack（拓扑+lca）
Coco_T的博客
11-05 891
分析： 如果整个图是一棵树，那么针对每个询问 必经路径就是k个点的lca到根节点的路径 实际上扩展成一个普通的图也是这样听男生们在讨论的时候，说这道题和灾难那道题”一样“ 我仔细一想，确实哎， 我们现在手上的图是一个DAG 首先我们把ta的拓扑序计算出来 之后构造一个“拓扑树”： 假设当前点是x，x的祖先一定都在拓扑树中了我们要找到与原图中直接指向x的所有点在拓扑树中的lca，把x挂
Matrix-Tree定理（sx之前填坑还来得及吗）
Coco_T的博客
03-28 665
从入门到入土：矩阵树Matrix-Tree定理 参考blog 在正式介绍Matrix_Tree定理之前，我们需要一些前置知识 一些定义与定理 对于一个无向图GGG，ta的生成树个数等于其基尔霍夫Kirchhhoff矩阵任何一个N−1N−1N-1阶主子式的行列式的绝对值 所谓N−1N−1N-1阶主子式就是对于任意的一个r，将矩阵的第rrr行和第rrr列同时删去得到的新矩阵 基尔霍夫Ki...
luoguP1073 最优贸易
Coco_T的博客
08-07 646
题目描述C 国有 n 个大城市和 m 条道路，每条道路连接这 n 个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这 m 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为 1 条。C 国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。商人阿龙来到
Tyvj（无向图的桥）
Coco_T的博客
09-29 624
题目链接分析： 无向图的桥tip这么裸的题我为什么没有一A呢 因为我又把n和m搞混啦！！！这里写代码片 #include<cstdio> #include<cstring> #include<iostream> #include<algorithm>using namespace std;const int N=210; int n,m; struct node{ int x,y,nxt
bzoj4773 负环
Coco_T的博客
08-26 619
Description 在忘记考虑负环之后，黎瑟的算法又出错了。对于边带权的有向图 G = (V, E)，请找出一个点数最小的环，使得 环上的边权和为负数。保证图中不包含重边和自环。Input 第1两个整数n, m,表示图的点数和边数。 接下来的m行，每<=三个整数ui, vi, wi，表<=有一条从ui到vi，权值为wi的有向边。 2 <= n <= 300 0 <= m <= n(n
torch.sparse.linalg.eigsh
最新发布
07-28
- *1* [深度学习矩阵乘法的终极奥义einsum，结合多个计算框架上的使用](https://blog.csdn.net/DBC_121/article/details/109566151)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值