那一天我们许下约定

内部题,题干不粘了。

$30分算法$


首先看数据范围,可以写出来一个普通dp

#include<bits/stdc++.h>
#define ll int
#define A 2100
#define mod 998244353
using namespace std;
ll f[1501][A+A+A],n,d,m;
int main()
{
scanf("%d%d%d",&n,&d,&m);
while(n!=0&&d!=0&&m!=0){
memset(f,0,sizeof(f));
f[0][0]=1;
for(ll i=1;i<=d;i++)
f[0][i]=1;
for(ll i=1;i<=n;i++)
for(ll k=1;k<=d;k++)
{
for(ll j=min(m-1,i);j>=0;j--)
if(i-j>=0) f[i][k]=(f[i][k]+f[i-j][k-1])%mod;
}
printf("%d\n",f[n][d]);
scanf("%d%d%d",&n,&d,&m);
}
}

d最大为$1e^12$所以你这个dp会完美T掉或者M掉

$100分算法$


观察,发现n的范围非常小,m的范围也特别小。

所以我们利用这条性质,先片面的忽视掉这一天不给她饼干的情况,我们设定$f$定义为每天都给她饼干的情况。

设$f[i][j]$中i表示为前$i$天目前给了$j$个饼干的情况

然后可以推出来方程式

可以给她1~m-1个饼干

$f[i][j]=\sum_\limits {k=(j-M-1)}^{k<=j-1} f[i-1][k]$

然后直接转移,复杂度仍然难以接受,观察dp式子发现它是由一个字段转移过来的,我们要用前缀和维护优化一下。

仍然AC不了?

可能你会乘爆long long

注意多取模

#include<bits/stdc++.h>
#define ll long long
#define A 2010
#define mod 998244353
using namespace std;
ll f[A][A],n,m,q,d;
ll sum[A];
ll meng(ll x,ll k)
{
ll ans=1;
for(;k;k>>=1,x=x*x%mod)
if(k&1)
ans=x*ans%mod;
return ans%mod;
}
int main(){ while(1){
scanf("%lld%lld%lld",&n,&d,&m);
ll ans=0;
if(n==0&&d==0&&m==0){
return 0;
}
memset(f[1],0,sizeof(f[1]));
f[0][0]=1;
for(ll i=1;i<=min(n,m-1);i++)
f[1][i]=1;
for(ll i=2;i<=n;i++){
for(ll j=0;j<=n;j++)
sum[j]=(sum[j-1]%mod+f[i-1][j]%mod)%mod;
for(ll j=1;j<=n;j++)
f[i][j]=(sum[j-1]%mod-sum[max(j-m,0ll)]%mod+mod)%mod;
}
ll sd=d%mod;
for(ll i=1;i<=min(n,d);i++)
{
if(i==1)
ans=(ans+sd*f[i][n]%mod)%mod,ans%=mod;
else{
sd=(sd%mod*meng(i,mod-2)%mod*((d-i+1)%mod))%mod;
ans%=mod;
ans=(ans+f[i][n]%mod*sd%mod)%mod;
}
// if(sd!=0)printf("sd=%lld ans=%lld f*s=%lld\n",sd,ans,f[i][n]*sd%mod);
}
cout<<(ans+mod)%mod<<endl;
}
}

那一天她离我而去

听说暴力可以AC所以我打的A*???

看不懂题解,如果给一个菊花图题解不就爆炸了吗?$2^{10000}$我觉得会炸

所以这个题瞎搞就行了???

然后我就瞎搞了个A*

跑的还特别快。大约600毫。

思路大约就是把每个直接与1相连的点拿出来,然后对于每个点跑A*,因为已经提前处理出来各种dis所以比较快。

然后没了

#include<bits/stdc++.h>
using namespace std;
#define ll int
#define A 100010
#define in inline
ll n,m;
bool flag[A],ok=0;
ll head[A],nxt[A],ver[A],tot1=0,t;
ll head2[A],nxt2[A],ver2[A],cnt=0,tot2=0;
ll value[A],value2[A],e,d[A],len=0;
struct qnode{
ll v,w,sz,id;
friend bool operator < (qnode x,qnode y)
{
return x.w+d[x.v]>y.w+d[y.v];
}
};
void re()
{
tot1=1,tot2=1;
memset(flag,0,sizeof(flag));
memset(head,0,sizeof(head));memset(head2,0,sizeof(head2));
memset(ver,0,sizeof(ver));memset(ver2,0,sizeof(ver2));
memset(nxt,0,sizeof(nxt));memset(nxt2,0,sizeof(nxt2));
memset(value,0,sizeof(value));memset(value2,0,sizeof(value2));
}
in void add1(ll u,ll v,ll w)
{
ver[++tot1]=v;
nxt[tot1]=head[u];
value[tot1]=w;
head[u]=tot1;
}
in void add2(ll x,ll y,ll w)
{
ver2[++tot2]=y;
nxt2[tot2]=head2[x];
value2[tot2]=w;
head2[x]=tot2;
}
in void spfa(ll root)
{
memset(flag,0,sizeof(flag));
memset(d,0x3f,sizeof(d));
queue <ll>q;
q.push(root);
flag[root]=1;
d[root]=0;
while(!q.empty())
{
ll x=q.front();
q.pop();
flag[x]=0;
for(ll i=head[x];i;i=nxt[i])
{
ll y=ver[i],w=value[i];
if(d[y]>d[x]+w)
{
d[y]=d[x]+w;
if(!flag[y])
{
flag[y]=1;
q.push(y);
}
}
}
}
return ;
}
in ll read()
{
ll x=0,f=1;char c=getchar();
while(!isdigit(c))
{
if(c=='-') f=-1;
c=getchar();
}
while(isdigit(c))
{
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
in ll astar()
{
// 从每个直接相连的点开始跑A*
ll ans=0x7ffffff;
for(ll i=head[1];i;i=nxt[i])
{
ll y=ver[i];
priority_queue<qnode> h;
memset(flag,0,sizeof(flag));
qnode s;
s.v=y,s.w=value[i],s.id=0;
h.push(s);
bool ok=0;
while(!h.empty())
{
qnode no=h.top();
// printf("当前 %d sumvalue=%d\n",no.v,no.w);
if(no.v==1){
ans=min(no.w,ans);
break;
}
h.pop();
flag[no.v]=1;
for(ll i=head2[no.v];i;i=nxt2[i]){
ll tu=ver2[i];
// printf("tu=%d\n",tu);
if(tu==1&&!ok){
ok=1;
// printf("tu=%d \n",tu);
continue;
}
if(flag[tu])
{/*printf("掠过\n");*/continue;}
// printf("没有掠过\n");
qnode t;
t.v=tu;t.w=value[i]+no.w;t.sz=no.sz+1;
h.push(t);
// printf("推入 %d->%d z=%d\n",no.v,tu,value2[i]+no.w);
}
}
}
return ans;
} int main()
{
scanf("%d",&t);
while(t--)
{
re();
ll xx,yy;ll zz;
n=read(),m=read();
for(ll i=1;i<=m;i++)
{
xx=read(),yy=read();zz=read();
add1(yy,xx,zz);
add1(xx,yy,zz);
add2(xx,yy,zz);
add2(yy,xx,zz);
}
spfa(1);
/* for(ll i=2;i<=tot1;i++){
printf("%d\n",ver[i]);
}
for(ll i=1;i<=n;i++){
printf("%d\n",d[i]);
}
*/ ok=1;
ll ans=astar();
if(ans>=1000000) cout<<-1<<endl;
else
printf("%d\n",ans);
}
}

NOIP模拟测试6「那一天我们许下约定(背包dp)·那一天她离我而去」的更多相关文章

  1. NOIP模拟测试19「count·dinner·chess」

    反思: 我考得最炸的一次 怎么说呢?简单的两个题0分,稍难(我还不敢说难,肯定又有人喷我)42分 前10分钟看T1,不会,觉得不可做,完全不可做,把它跳了 最后10分钟看T1,发现一个有点用的性质,仍 ...

  2. NOIP模拟测试30「return·one·magic」

    magic 题解 首先原式指数肯定会爆$long$ $long$ 首先根据欧拉定理我们可以将原式换成$N^{\sum\limits_{i=1}^{i<=N} [gcd(i,N)==1] C_{G ...

  3. NOIP模拟测试21「折纸&#183;不等式」

    折纸 题解 考试时无限接近正解,然而最终也只是接近而已了 考虑模拟会爆炸,拿手折纸条试一试,很简单 考你动手能力 代码 #include<bits/stdc++.h> using name ...

  4. NOIP模拟测试18「引子·可爱宝贝精灵·相互再归的鹅妈妈」

    待补 引子 题解 大模拟,注意细节 代码1 #include<bits/stdc++.h> using namespace std; int n,m;char a[1005][1005]; ...

  5. NOIP模拟测试10「大佬·辣鸡·模板」

    大佬 显然假期望 我奇思妙想出了一个式子$f[i]=f[i-1]+\sum\limits_{j=1}^{j<=m} C_{k \times j}^{k}\times w[j]$ 然后一想不对得容 ...

  6. 20190803 NOIP模拟测试12「斐波那契(fibonacci)· 数颜色 · 分组 」

    164分 rank11/64 这次考的不算太差,但是并没有多大的可能性反超(只比一小部分人高十几分而已),时间分配还是不均,T2两个半小时,T1半个小时,T3-额十几分钟吧 然额付出总是与回报成反比的 ...

  7. NOIP模拟测试8「寿司」

    考试时打的类似$n^2$暴力,然后炸了只有10分 后来验证我的算法伪了. 题解 显然你有一种解法,假设你要在一个B点断开将R分别移向最左 最右,这样只用分别计算B点右面蓝色数量左面蓝色数量就得到了一个 ...

  8. NOIP模拟测试38「金·斯诺·赤」

    金 辗转相减见祖宗 高精 #include<bits/stdc++.h> using namespace std; #define A 2000 #define P 1 #define N ...

  9. NOIP模拟测试28「阴阳·虎·山洞」

    写这几个题解我觉得我就像在按照官方题解抄一样 阴阳 题解 将题目中给的阴阳看作黑色和白色 首先我们观察到最后生成图中某种颜色必须是竖着单调递增或竖着单调递减 类似这样 否则不满足这个条件 但合法染色方 ...

随机推荐

  1. Unittest框架之测试套件:TestSuite

    前言 使用了unittest.main()方法执行当前模块里的测试用例. 除此之外,Unittest还可以通过测试套件构造测试用例集,再执行测试用例 将测试用例添加至TestSuite(测试套件) 方 ...

  2. mxgraph中mxStencil使用教程

    目录 标签嵌套关系 Shapes shape connections background foreground 其他样式 图形内部颜色绘制 封闭线段绘制 设置一条线的颜色大小 样例 官方文档:htt ...

  3. 普里姆算法(Prim)邻接矩阵法

    算法代码 C#代码 using System; namespace Prim { class Program { static void Main(string[] args) { int numbe ...

  4. volatile 的使用

    ① 编译器很聪明,会帮我们做些优化,比如: int a; a = 0; // 这句话可以优化掉,不影响 a 的结果 a = 1; ② 有时候编译器会自作聪明,比如: int *p = ioremap( ...

  5. 常用加密算法学习总结之散列函数(hash function)

    散列函数(Hash function)又称散列算法.哈希函数,散列函数把消息或数据压缩成摘要,使得数据量变小,将数据的格式固定下来.该函数将数据打乱混合,重新创建一个叫做散列值(hash values ...

  6. 封装axios在util中

    创建util工具类,封装通用的get和post请求 封装axios成工具类,方便大家请求调用 1.创建util文件夹 2.创建request.js 3.封装 //封装请求相关方法 //初始化一个axi ...

  7. [笔记] 《c++ primer》书店程序 Chapter2

    Sales_data.h 1 #ifndef SALES_DATA_H 2 #define SALES_DATA_H 3 4 #include "Version_test.h" 5 ...

  8. 【转载】有图 KVM折腾记..

    KVM折腾记...https://lengjibo.github.io/KVM%E6%8A%98%E8%85%BE%E8%AE%B0/  Veröffentlicht am 2018-09-20 |  ...

  9. Docker Swarm(四)Volume 数据(挂载)持久化

    前言 为了获得最佳的性能和可移植性,应该避免将重要数据直接写入容器的可写层,而应使用数据卷或绑定挂载. 可以为集群中的服务创建两种类型的挂载,数据卷挂载(volume mounts)或绑定挂载(bin ...

  10. Linux服务之cobbler批量部署篇

    一.Cobbler简介:Cobbler通过将设置和管理一个安装服务器所涉及的任务集中在一起,从而简化了系统配置.相当于Cobbler封装了DHCP.TFTP.XINTED等服务,结合了PXE.kick ...