dp 订阅
DisplayPort(简称DP)是一个由PC及芯片制造商联盟开发,视频电子标准协会(VESA)标准化的数字式视频接口标准。该接口免认证、免授权金,主要用于视频源与显示器等设备的连接,并也支持携带音频、USB和其他形式的数据。此接口的设计是为取代传统的VGA、DVI和FPD-Link(LVDS)接口。通过主动或被动适配器,该接口可与传统接口(如HDMI和DVI)向后兼容。 展开全文
DisplayPort(简称DP)是一个由PC及芯片制造商联盟开发,视频电子标准协会(VESA)标准化的数字式视频接口标准。该接口免认证、免授权金,主要用于视频源与显示器等设备的连接,并也支持携带音频、USB和其他形式的数据。此接口的设计是为取代传统的VGA、DVI和FPD-Link(LVDS)接口。通过主动或被动适配器,该接口可与传统接口(如HDMI和DVI)向后兼容。
信息
定    义
数字式视频接口标准
简    称
DP
开发者
PC及芯片制造商联盟
中文名
显示接口
学    科
通讯工程
外文名
DisplayPort
DisplayPort接口概观
DisplayPort是第一个依赖数据包化数据传输技术的显示通信端口,这种数据包化传输技术可以在以太网、USB和PCI Express等技术中找到。它既可以用于内部显示连接,也可以用于外部的显示连接。与过去的标准需要在每个输出端的差分对里面固定传输定时器信号不同的是,DisplayPort协议是基于小的数据报文被称为微报文,这种微报文可以将定时器信号嵌入在数据流中。其优点是较少的引脚数,就可以实现更高的分辨率。数据报文的应用也允许使用DisplayPort可扩展,这就意味着随着时间的推移,物理通信端口本身不需要显著的变化就可以增加额外的功能了。 [1]  DisplayPort可用于同时传输音频和视频,这两项中每一项都可以在没有另外一项的基础上单独传输。视频信号路径中每个颜色通道可以有6到16位,音频路径可以有多达8通道24位192 kHz的非压缩的PCM音频,或可以在音频流中封装压缩的音频格式。一个双向的、半双工的辅助通道携带了主链接用的设备管理和设备控制数据,如VESAEDID、MCCS和DPMS标准。此外,该通信端口是能够运送双向USB信号。DisplayPort信号不兼容DVI或HDMI。然而,双模式DisplayPorts被设计用来通过该通信端口传输单链接DVI或HDMI1.2/1.4的协议,需要通过使用一个外部无源连接器来实现,选择所需的信号,并将电气信号从LVDS转换为TMDS。带有被动连接器的双模DisplayPorts不支持VGA和双链接DVI。这些通信端口需要有源连接器来转换所需要输出的协议和信号。VGA连接器可以使用DisplayPort连接器来供电,而双链接DVI连接器可能依赖于外部电源(参考HDMI、DVI和VGA兼容性)。DisplayPort连接器在主链路可以有1、2、或4路差分数据对(巷道),每巷道可以在自定时器运行于162、270、或540MHz的基础上其原始码率为1.62、2.7或者5.4 Gbit/s。数据为8b/10b编码,即每8位的消息被编入10比特符号中。因此,解码后每通道的有效数据传输速率是1.296、2.16、4.32 Gbit/s(或者说是总量的80%)。
收起全文
精华内容
下载资源
问答
  • 小 x 对数位 dp 很感兴趣,现在他在解决一道题目,要求求解出[x,y]闭区间内所有满足以下性质的数字个数: 相邻位数字差值的绝对值不能超过 7。 且最低位与最高位差值的绝对值要大于 2。 现在,给出 x=13930,y=...

    Description

    小 x 对数位 dp 很感兴趣,现在他在解决一道题目,要求求解出[x,y]闭区间内所有满足以下性质的数字个数:

    1. 相邻位数字差值的绝对值不能超过 7。
    2. 且最低位与最高位差值的绝对值要大于 2。
      现在,给出 x=13930,y=457439。请你告诉小 x,满足要求的数字个数。

    思路分析

    x和y都不是很大,直接暴力搜索就行。

    #include<bits/stdc++.h>
    using namespace std;
    typedef long long ll;
    
    int solve(int x) {
    	int a[6];
    	int ind = 0;
    	while(x) {
    		int j = x % 10;
    		x /= 10;
    		a[ind++] = j;
    	}
    	if(abs(a[ind - 1] - a[0]) <= 2) {
    		return 0;
    	}
    	for(int i = 1; i < ind; i++) {
    		if(abs(a[i] - a[i - 1]) > 7) {
    			return 0;
    		}
    	}
    	return 1;
    }
    
    int main() {
    	int res = 0;
    	for(int i = 13930; i <= 457439; i++) {
    		if(solve(i)) {
    			res++;
    		}
    	}
    	cout << res;
    	return 0;
    }
    
    展开全文
  • 数位dp总结 之 从入门到模板

    万次阅读 多人点赞 2016-08-03 14:37:59
    数位dp是一种计数用的dp,一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp,字面意思就是在数位上进行dp咯。数位还算是比较好听的名字,数位的含义:一个数有个位、十位、百位、千位......数的每...


    基础篇

    数位dp是一种计数用的dp,一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp,字面意思就是在数位上进行dp咯。数位还算是比较好听的名字,数位的含义:一个数有个位、十位、百位、千位......数的每一位就是数位啦!

    之所以要引入数位的概念完全就是为了dp。数位dp的实质就是换一种暴力枚举的方式,使得新的枚举方式满足dp的性质,然后记忆化就可以了。

    两种不同的枚举:对于一个求区间[le,ri]满足条件数的个数,最简单的暴力如下:

    for(int i=le;i<=ri;i++)
            if(right(i)) ans++;

    然而这样枚举不方便记忆化,或者说根本无状态可言。

    新的枚举:控制上界枚举,从最高位开始往下枚举,例如:ri=213,那么我们从百位开始枚举:百位可能的情况有0,1,2(觉得这里枚举0有问题的继续看)

    然后每一位枚举都不能让枚举的这个数超过上界213(下界就是0或者1,这个次要),当百位枚举了1,那么十位枚举就是从0到9,因为百位1已经比上界2小了,后面数位枚举什么都不可能超过上界。所以问题就在于:当高位枚举刚好达到上界是,那么紧接着的一位枚举就有上界限制了。具体的这里如果百位枚举了2,那么十位的枚举情况就是0到1,如果前两位枚举了21,最后一位之是0到3(这一点正好对于代码模板里的一个变量limit 专门用来判断枚举范围)。最后一个问题:最高位枚举0:百位枚举0,相当于此时我枚举的这个数最多是两位数,如果十位继续枚举0,那么我枚举的就是以为数咯,因为我们要枚举的是小于等于ri的所以数,当然不能少了位数比ri小的咯!(这样枚举是为了无遗漏的枚举,不过可能会带来一个问题,就是前导零的问题,模板里用lead变量表示,不过这个不是每个题目都是会有影响的,可能前导零不会影响我们计数,具体要看题目)

    由于这种新的枚举只控制了上界所以我们的Main函数总是这样:

    int main()
    {
        long long le,ri;
        while(~scanf("%lld%lld",&le,&ri))
            printf("%lld\n",solve(ri)-solve(le-1));
    }
    w_w 是吧!统计[1,ri]数量和[1,le-1],然后相减就是区间[le,ri]的数量了,这里我写的下界是1,其实0也行,反正相减后就没了,注意题目中le的范围都是大于等于1的(不然le=0,再减一就G_G了)

    在讲例题之前先讲个基本的动态模板(先看后面的例题也行):dp思想,枚举到当前位置pos,状态为state(这个就是根据题目来的,可能很多,毕竟dp千变万化)的数量(既然是计数,dp值显然是保存满足条件数的个数)

    typedef long long ll;
    int a[20];
    ll dp[20][state];//不同题目状态不同
    ll dfs(int pos,/*state变量*/,bool lead/*前导零*/,bool limit/*数位上界变量*/)//不是每个题都要判断前导零
    {
        //递归边界,既然是按位枚举,最低位是0,那么pos==-1说明这个数我枚举完了
        if(pos==-1) return 1;/*这里一般返回1,表示你枚举的这个数是合法的,那么这里就需要你在枚举时必须每一位都要满足题目条件,也就是说当前枚举到pos位,一定要保证前面已经枚举的数位是合法的。不过具体题目不同或者写法不同的话不一定要返回1 */
        //第二个就是记忆化(在此前可能不同题目还能有一些剪枝)
        if(!limit && !lead && dp[pos][state]!=-1) return dp[pos][state];
        /*常规写法都是在没有限制的条件记忆化,这里与下面记录状态是对应,具体为什么是有条件的记忆化后面会讲*/
        int up=limit?a[pos]:9;//根据limit判断枚举的上界up;这个的例子前面用213讲过了
        ll ans=0;
        //开始计数
        for(int i=0;i<=up;i++)//枚举,然后把不同情况的个数加到ans就可以了
        {
            if() ...
            else if()...
            ans+=dfs(pos-1,/*状态转移*/,lead && i==0,limit && i==a[pos]) //最后两个变量传参都是这样写的
            /*这里还算比较灵活,不过做几个题就觉得这里也是套路了
            大概就是说,我当前数位枚举的数是i,然后根据题目的约束条件分类讨论
            去计算不同情况下的个数,还有要根据state变量来保证i的合法性,比如题目
            要求数位上不能有62连续出现,那么就是state就是要保存前一位pre,然后分类,
            前一位如果是6那么这意味就不能是2,这里一定要保存枚举的这个数是合法*/
        }
        //计算完,记录状态
        if(!limit && !lead) dp[pos][state]=ans;
        /*这里对应上面的记忆化,在一定条件下时记录,保证一致性,当然如果约束条件不需要考虑lead,这里就是lead就完全不用考虑了*/
        return ans;
    }
    ll solve(ll x)
    {
        int pos=0;
        while(x)//把数位都分解出来
        {
            a[pos++]=x%10;//个人老是喜欢编号为[0,pos),看不惯的就按自己习惯来,反正注意数位边界就行
            x/=10;
        }
        return dfs(pos-1/*从最高位开始枚举*/,/*一系列状态 */,true,true);//刚开始最高位都是有限制并且有前导零的,显然比最高位还要高的一位视为0嘛
    }
    int main()
    {
        ll le,ri;
        while(~scanf("%lld%lld",&le,&ri))
        {
            //初始化dp数组为-1,这里还有更加优美的优化,后面讲
            printf("%lld\n",solve(ri)-solve(le-1));
        }
    }
    

    相信读者还对这个有不少疑问,笔者认为有必要讲一下记忆化为什么是if(!limit)才行,大致就是说有无limit会出现状态冲突,举例:

    约束:数位上不能出现连续的两个1(11、112、211都是不合法的)

    假设就是[1,210]这个区间的个数

    状态:dp[pos][pre]:当前枚举到pos位,前面一位枚举的是pre(更加前面的位已经合法了),的个数(我的pos从0开始)

    先看错误的方法计数,就是不判limit就是直接记忆化

    那么假设我们第一次枚举了百位是0,显然后面的枚举limit=false,也就是数位上0到9的枚举,然后当我十位枚举了1,此时考虑dp[0][1],就是枚举到个位,前一位是1的个数,显然dp[0][1]=9;(个位只有是1的时候是不满足的),这个状态记录下来,继续dfs,一直到百位枚举了2,十位枚举了1,显然此时递归到了pos=0,pre=1的层,而dp[0][1]的状态已经有了即dp[pos][pre]!=-1;此时程序直接return dp[0][1]了,然而显然是错的,因为此时是有limit的个位只能枚举0,根本没有9个数,这就是状态冲突了。有lead的时候可能出现冲突,这只是两个最基本的不同的题目可能还要加限制,反正宗旨都是让dp状态唯一

    对于这个错误说两点:一是limit为true的数并不多,一个个枚举不会很浪费时间,所以我们记录下! limit的状态解决了不少子问题重叠。第二,有人可能想到把dp状态改一下dp[pos][state][limit]就是分别记录不同limit下的个数,这种方法一般是对的,关于这个具体会讲,下面有题bzoj3209会用到这个。

    数位的部分就是这些,然后就是难点,dp部分,dp大牛的艺术,弱鸡只能看看+...+

    既然从高位往低位枚举,那么状态一般都是与前面已经枚举的数位有关并且通常是根据约束条件当前枚举的这一位能使得状态完整(比如一个状态涉及到连续k位,那么就保存前k-1的状态,当前枚举的第k个是个恰好凑成成一个完整的状态,不过像那种状态是数位的和就直接保存前缀和为状态了),不过必然有一位最简单的一个状态dp[pos]当前枚举到了pos位。dp部分就要开始讲例题了,不过会介绍几种常用防tle的优化。

    实战篇

    例一:HDU 2089 不要62
    入门题。就是数位上不能有4也不能有连续的62,没有4的话在枚举的时候判断一下,不枚举4就可以保证状态合法了,所以这个约束没有记忆化的必要,而对于62的话,涉及到两位,当前一位是6或者不是6这两种不同情况我计数是不相同的,所以要用状态来记录不同的方案数。
    dp[pos][sta]表示当前第pos位,前一位是否是6的状态,这里sta只需要去0和1两种状态就可以了,不是6的情况可视为同种,不会影响计数。
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<string>
    using namespace std;
    typedef long long ll;
    int a[20];
    int dp[20][2];
    int dfs(int pos,int pre,int sta,bool limit)
    {
        if(pos==-1) return 1;
        if(!limit && dp[pos][sta]!=-1) return dp[pos][sta];
        int up=limit ? a[pos] : 9;
        int tmp=0;
        for(int i=0;i<=up;i++)
        {
            if(pre==6 && i==2)continue;
            if(i==4) continue;//都是保证枚举合法性
            tmp+=dfs(pos-1,i,i==6,limit && i==a[pos]);
        }
        if(!limit) dp[pos][sta]=tmp;
        return tmp;
    }
    int solve(int x)
    {
        int pos=0;
        while(x)
        {
            a[pos++]=x%10;
            x/=10;
        }
        return dfs(pos-1,-1,0,true);
    }
    int main()
    {
        int le,ri;
        //memset(dp,-1,sizeof dp);可优化
        while(~scanf("%d%d",&le,&ri) && le+ri)
        {
            memset(dp,-1,sizeof dp);
            printf("%d\n",solve(ri)-solve(le-1));
        }
        return 0;
    }
    

    入门就不多讲了,开始讲常用优化吧!

    第一:memset(dp,-1,sizeof dp);放在多组数据外面。

    这一点是一个数位特点,使用的条件是:约束条件是每个数自身的属性,而与输入无关。
    具体的:上一题不要62和4,这个约束对每一个数都是确定的,就是说任意一个数满不满足这个约束都是确定,比如444这个数,它不满足约束条件,不管你输入的区间是多少你都无法改变这个数不满足约束这个事实,这就是数自身的属性(我们每组数据只是在区间计数而已,只能说你输入的区间不包含444的话,我们就不把它统计在内,而无法改变任何事实)。
    由此,我们保存的状态就可以一直用(注意还有要limit,不同区间是会影响数位在有限制条件下的上限的)
    这点优化就不给具体题目了,这个还有进一步的扩展。不过说几个我遇到的简单的约束:
    1.求数位和是10的倍数的个数,这里简化为数位sum%10这个状态,即dp[pos][sum]这里10 是与多组无关的,所以可以memset优化,不过注意如果题目的模是输入的话那就不能这样了。
    2.求二进制1的数量与0的数量相等的个数,这个也是数自身的属性。
    3.。。。。。
    还是做题积累吧。搞懂思想!
    下面介绍的方法就是要行memset优化,把不满足前提的通过修改,然后优化。
    介绍之前,先说一种较为笨拙的修改,那就是增加状态,前面讲limit的地方说增加一维dp[pos][state][limit],能把不同情况下状态分别记录(不过这个不能memset放外面)。基于这个思想,我们考虑:约束为数位是p的倍数的个数,其中p数输入的,这和上面sum%10类似,但是dp[pos][sum]显然已经不行了,每次p可能都不一样,为了强行把memset提到外面加状态dp[pos][sum][p],对于每个不同p分别保存对应的状态。这里前提就比较简单了,你dp数组必须合法,p太大就G_G了。所以对于与输入有关的约束都可以强行增加状态(这并不代表能ac,如果题目数据少的话就随便你乱搞了)

    第二:相减。

    例题:HDU 4734
    题目给了个f(x)的定义:F(x) = An * 2n-1 + An-1 * 2n-2 + ... + A2 * 2 + A1 * 1,Ai是十进制数位,然后给出a,b求区间[0,b]内满足f(i)<=f(a)的i的个数。
    常规想:这个f(x)计算就和数位计算是一样的,就是加了权值,所以dp[pos][sum],这状态是基本的。a是题目给定的,f(a)是变化的不过f(a)最大好像是4600的样子。如果要memset优化就要加一维存f(a)的不同取值,那就是dp[10][4600][4600],这显然不合法。
    这个时候就要用减法了,dp[pos][sum],sum不是存当前枚举的数的前缀和(加权的),而是枚举到当前pos位,后面还需要凑sum的权值和的个数,
    也就是说初始的是时候sum是f(a),枚举一位就减去这一位在计算f(i)的权值,那么最后枚举完所有位 sum>=0时就是满足的,后面的位数凑足sum位就可以了。
    仔细想想这个状态是与f(a)无关的(新手似乎很难理解),一个状态只有在sum>=0时才满足,如果我们按常规的思想求f(i)的话,那么最后sum>=f(a)才是满足的条件。
    #include<cstdio>
    #include<cstring>
    #include<iostream>
    #include<string>
    
    using namespace std;
    const int N=1e4+5;
    int dp[12][N];
    int f(int x)
    {
        if(x==0) return 0;
        int ans=f(x/10);
        return ans*2+(x%10);
    }
    int all;
    int a[12];
    int dfs(int pos,int sum,bool limit)
    {
        if(pos==-1) {return sum<=all;}
        if(sum>all) return 0;
        if(!limit && dp[pos][all-sum]!=-1) return dp[pos][all-sum];
        int up=limit ? a[pos] : 9;
        int ans=0;
        for(int i=0;i<=up;i++)
        {
            ans+=dfs(pos-1,sum+i*(1<<pos),limit && i==a[pos]);
        }
        if(!limit) dp[pos][all-sum]=ans;
        return ans;
    }
    int solve(int x)
    {
        int pos=0;
        while(x)
        {
            a[pos++]=x%10;
            x/=10;
        }
        return dfs(pos-1,0,true);
    }
    int main()
    {
        int a,ri;
        int T_T;
        int kase=1;
        scanf("%d",&T_T);
        memset(dp,-1,sizeof dp);
        while(T_T--)
        {
            scanf("%d%d",&a,&ri);
            all=f(a);
            printf("Case #%d: %d\n",kase++,solve(ri));
        }
        return 0;
    }

    减法的艺术!!!

    例题 POJ 3252
    这题的约束就是一个数的二进制中0的数量要不能少于1的数量,通过上一题,这题状态就很简单了,dp[pos][num],到当前数位pos,0的数量减去1的数量不少于num的方案数,一个简单的问题,中间某个pos位上num可能为负数(这不一定是非法的,因为我还没枚举完嘛,只要最终的num>=0才能判合法,中途某个pos就不一定了),这里比较好处理,Hash嘛,最小就-32吧(好像),直接加上32,把32当0用。这题主要是要想讲一下lead的用法,显然我要统计0的数量,前导零是有影响的。至于!lead&&!limit才能dp,都是类似的,自己慢慢体会吧。
    #pragma comment(linker, "/STACK:10240000,10240000")
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<string>
    #include<queue>
    #include<set>
    #include<vector>
    #include<map>
    #include<stack>
    #include<cmath>
    #include<algorithm>
    using namespace std;
    const double R=0.5772156649015328606065120900;
    const int N=1e5+5;
    const int mod=1e9+7;
    const int INF=0x3f3f3f3f;
    const double eps=1e-8;
    const double pi=acos(-1.0);
    typedef long long ll;
    int dp[35][66];
    int a[66];
    int dfs(int pos,int sta,bool lead,bool limit)
    {
        if(pos==-1)
            return sta>=32;
        if(!limit && !lead && dp[pos][sta]!=-1) return dp[pos][sta];
        int up=limit?a[pos]:1;
        int ans=0;
        for(int i=0;i<=up;i++)
        {
            if(lead && i==0) ans+=dfs(pos-1,sta,lead,limit && i==a[pos]);//有前导零就不统计在内
            else ans+=dfs(pos-1,sta+(i==0?1:-1),lead && i==0,limit && i==a[pos]);
        }
        if(!limit && !lead ) dp[pos][sta]=ans;
        return ans;
    }
    int solve(int x)
    {
        int pos=0;
        while(x)
        {
            a[pos++]=x&1;
            x>>=1;
        }
        return dfs(pos-1,32,true,true);
    }
    int main()
    {
        memset(dp,-1,sizeof dp);
        int a,b;
        while(~scanf("%d%d",&a,&b))
        {
            printf("%d\n",solve(b)-solve(a-1));
        }
        return 0;
    }
    然后就是一些需要自己yy的题:
    HDU 3709 这题就是要枚举中轴,然后数位dp
    UVA 1305 这题我二分然后数位dp搞(好像不是正解,我水过的)
    Hbzoj 1799 这题讲一下:
    (偷偷告诉你,这个oj是单组测试,然后memset什么的都是浮云了)
    约束:一个数是它自己数位和的倍数,直接dp根本找不到状态,枚举数位和,因为总就162,然后问题就变成了一个数%mod=0,mod是枚举的,想想状态:dp[pos][sum][val],当前pos位上数位和是sum,val就是在算这个数%mod,(从高位算  *10+i),因为我们枚举的数要保证数位和等于mod,还要保证这个数是mod的倍数,很自然就能找到这些状态,显然对于每一个mod,val不能保证状态唯一,这是你要是想加一维dp[pos][sum][val][mod],记录每一个mod的状态(这里sum可以用减法,然而val不行,就只能加一维),那你就想太多了,这样是会超时的(因为状态太多,记忆化效果不好)。这里直接对每一个mod,memset一次就能ac。下面的代码还把limit的当做了状态,因为每次都要初始化,所以能这样,memset在多组外面是不能这样的,不过奇葩的,这代码,如果不把limit当状态,还是在!limit 条件下记录dp,提交一发,时间竟然更短了,可能是每次memset的关系!!!
    #include<cstdio>
    #include<cstring>
    #include<iostream>
    #include<string>
    
    using namespace std;
    
    typedef long long ll;
    
    ll dp[20][163][163][2];
    int a[20];
    ll dfs(int pos,int sum,int val,int mod,bool limit)
    {
        if(sum-9*pos-9>0) return 0;//最坏的情况,这一位及后面的全部为9都不能达到0那就直接GG,这个剪枝不会影响ac
        if(pos==-1) return sum==0 && val==0;
        if(dp[pos][sum][val][limit]!=-1) return dp[pos][sum][val][limit];
        int up=limit?a[pos]:9;
        ll ans=0;
        for(int i=0;i<=up;i++)
        {
            if(sum-i<0) break;
            ans+=dfs(pos-1,sum-i,(val*10+i)%mod,mod,limit && i==a[pos]);
        }
        dp[pos][sum][val][limit]=ans;
        return ans;
    }
    ll solve(ll x)
    {
        int pos=0;
        while(x)
        {
            a[pos++]=x%10;
            x/=10;
        }
        ll ans=0;
        for(int i=1;i<=pos*9;i++)//上限就是每一位都是9
        {
            memset(dp,-1,sizeof dp);
            ll tmp=dfs(pos-1,i,0,i,true);
            ans+=tmp;
        }
        return ans;
    }
    int main()
    {
    //    cout<<18*9<<endl;
        ll le,ri;
    //    memset(dp,-1,sizeof dp);
        while(~scanf("%lld%lld",&le,&ri))
            printf("%lld\n",solve(ri)-solve(le-1));
        return 0;
    }
    /*
    1 1000000000000000000
    */
    
    基本讲的差不多了。前段时间学了点新东西!!

    新的领域--计数转求和

    这题麻烦就是要求数的平方和。
    我们先考虑求和的问题,一个区间,数位dp能在一些约束下计数,现在要这些数的和。其实组合数学搞搞就可以了:如 现在枚举的某一位pos,我统计了这一位枚举i的满足条件的个数cnt,其实只要算i对总和的贡献就可以了,对于一个数而言第pos位是i,那么对求和贡献就是i*10^pos,就是十进制的权值,然后有cnt个数都满足第pos位是i,最后sum=cnt*i*10^pos.原理就是这样平方和可以看做(a*10^pos+b)^2,a是你当前pos位要枚举的,b其实是个子问题,就是pos之后的位的贡献值,把这个平方展开就可以了!
    #pragma comment(linker, "/STACK:10240000,10240000")
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<string>
    #include<queue>
    #include<set>
    #include<vector>
    #include<map>
    #include<stack>
    #include<cmath>
    #include<algorithm>
    using namespace std;
    const double R=0.5772156649015328606065120900;
    const int N=1e5+5;
    const int mod=1e9+7;
    const int INF=0x3f3f3f3f;
    const double eps=1e-8;
    const double pi=acos(-1.0);
    typedef long long ll;
    ll fact[20];
    void init()
    {
        fact[0]=1;
        for(int i=1;i<20;i++)
            fact[i]=fact[i-1]*10%mod;
    }
    struct node
    {
        ll cnt,sum,sqr;
        node(ll cnt=-1,ll sum=0,ll sqr=0):cnt(cnt),sum(sum),sqr(sqr){}
    }dp[20][7][7];
    int a[20];
    ll fac(ll x)
    {
        return x*x%mod;
    }
    ll dfs(int pos,ll num,ll val,ll&cnt,ll&sum,bool limit)
    {
        if(pos==-1) {
            if(num==0 || val==0)
                return 0;
            cnt=1;
            return 0;
        }
        if(!limit && dp[pos][num][val].cnt!=-1) {
                cnt=dp[pos][num][val].cnt;
                sum=dp[pos][num][val].sum;
                return dp[pos][num][val].sqr;
        }
        int up=limit?a[pos]:9;
        ll sq=0;
        for(int i=0;i<=up;i++)
        if(i!=7)
        {
            ll cn=0,su=0;
            ll tmp=dfs(pos-1,(num+i)%7,(val*10+i)%7,cn,su,limit && i==a[pos]);
            ll tm=i*fact[pos]%mod;
            tmp=(tmp+fac(tm)*cn%mod+(tm*su%mod)*2%mod)%mod;//计数之后要更新sum,sqr
            sum=(sum+su+(i*fact[pos]%mod)*cn%mod)%mod;
            cnt=(cnt+cn)%mod;
            sq=(sq+tmp)%mod;
        }
        if(!limit) dp[pos][num][val]=node(cnt,sum,sq);
        return sq;
    }
    ll solve(ll x)
    {
        int pos=0;
        while(x)
        {
            a[pos++]=x%10;
            x/=10;
        }
        ll t1=0,t2=0;
        return dfs(pos-1,0,0,t1,t2,true);
    }
    bool judge(ll x)
    {
        int sum=0;
        int pos=0;
        if(x%7==0) return false;
        while(x)
        {
            if(x%10==7) return false;
            sum+=x%10;
            x/=10;
        }
        sum%=7;
        return sum!=0;
    }
    int main()
    {
        init();
        for(int i=0;i<20;i++)
            for(int j=0;j<7;j++)
            for(int k=0;k<7;k++)//memset
        {
            dp[i][j][k].cnt=-1;
            dp[i][j][k].sum=0;
            dp[i][j][k].sqr=0;
        }
        int T_T;
        scanf("%d",&T_T);
        while(T_T--)
        {
            ll le,ri;
            scanf("%I64d%I64d",&le,&ri);
            ll ans=solve(ri)-solve(le-1);
            ans=(ans%mod+mod)%mod;
            printf("%I64d\n",ans);
        }
        return 0;
    }
    做题去~~


    展开全文
  • 动态规划(DP)

    千次阅读 多人点赞 2020-04-15 23:33:23
    DP

    动态规划(DP)
    用来优化加速,时间复杂度从指数(Exponential) 加速到多项式时间(Polynomial)。
    何时使用DP?

    • 计数问题:求有多少种方法
    • 优化问题:max和min问题

    使用DP的要求

    • 最优子结构
    • 重复子问题:求解子问题时,会出现重复计算(overlapping)。如果没有重复计算,则退化成分治算法(divide and conquer)
    • 无后效性:调用子问题最优解时,子问题的最优解不发生改变。

    使用方法

    1. 带有记忆性的递归
      举例:斐波那契序列
    2. DP
      举例:LIS(最长上升子序列),LCS(最长公共子序列)

    典型题目

    斐波那契序列

    分析
    递推公式和边界条件已知。存在重复计算的问题,类似带有记忆性的递归,即使用数组保存先前的结果,减少重复计算。

    开一个数组dp[]
    for i in range(3,n)
    dp[i]=dp[i-1]+dp[i-2]
    仅需一个for loop

    代码

    int DP(int n)
    {
    	int dp[n+1];
    	dp[1]=1;dp[2]=1;
    	for(int i=3;i<=n;i++)
    		dp[i]=dp[i-1]+dp[i-2];
    	return dp[n];
    }
    

    三角形数

    题目
    给定一个由行数字组成的数字三角形。试着设计一个算法,计算出从三角形的顶到底的一条路径,使得该路径经过的数字总和最大。
    测试数据

    1
    2 3
    20 5 6
    7 8 9 10
    最大值 31

    思路1:
    自底向上方向,MaxSum[ i ] [ j ]表示第i行第j列的数到最底下路径和的最大值。
    MaxSum[ i] [ j] 和MaxSum[ i ][ j+1]中的较大者,作为第i-1行的转移项。
    代码

    #include<iostream>
    
    using namespace std;
    
    const int maxn=1e2+2;
    
    int D[maxn][maxn],MaxSum[maxn][maxn]; 
    int main()
    {
    	int i,j;
    	int N;
    	cin>>N;//输入N行测试数据
    	for(i=1;i<=N;i++)
    		for(j=1;j<=i;j++) 
    			cin>>D[i][j];
    
    	for(i=1;i<=N;i++)//最大权值和初始化为最后一列 
    		MaxSum[N][i]=D[N][i];
    		
    	for(i=N;i>1;i--)
    		for(j=1;j<i;j++)
    		{
    			if(MaxSum[i][j]>MaxSum[i][j+1])//比较左右两边数据大小 
    				MaxSum[i-1][j]=D[i-1][j]+MaxSum[i][j];//更新上一行最大权值的和 
    			else
    				MaxSum[i-1][j]=D[i-1][j]+MaxSum[i][j+1];
    		}
    	//最大值在MaxSum[1][1]
    	cout<<MaxSum[1][1]<<endl;	
    } 
    

    需要注意
    注意数组的边界,数组不是从0开始,这里使用从1开始。
    对于第i行,需要使用第i+1行的数据,对于for(i=N;i>1;i–)这里

    思路2:自上到下,思路在下方代码上面。

    下面这道题目可能包含负数。

    Acwing898. 数字三角形

    输入格式
    第一行包含整数n,表示数字三角形的层数。

    接下来n行,每行包含若干整数,其中第 i 行表示数字三角形第 i 层包含的整数。

    输出格式
    输出一个整数,表示最大的路径数字和。

    数据范围
    1≤n≤500,
    −10000≤三角形中的整数≤10000
    输入样例:
    5
    7
    3 8
    8 1 0
    2 7 4 4
    4 5 2 6 5
    输出样例:
    30

    
    /*
    
    数字三角形思路分析;
    
    状态表示f[i,j]
        集合:所有从起点到(i,j)的路径
        属性:max
    
    状态计算
    f[i,j]可以来自左上和右上两种情况:
        左上:f[i-1][j-1]+a[i][j]
        右上:f[i-1][j]+a[i][j]
    
    */
    
    
    /*
        dp问题的时间复杂度分析:  状态数量 × 转移的计算量
        
        本题:状态数量n^2 ,转移计算量O(1),所以本题时间复杂度O(n^2)
    */
    
    #include<bits/stdc++.h>
    using namespace std;
    const int N=510,INF=1e9;
    int n;
    int f[N][N];
    
    int a[N][N];
    
    int main(){
        cin>>n;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++)
                cin>>a[i][j];
        }
        
        //初始化多初始化两侧两列:因为计算 f[i][1]需要用到f[i-1][0],这里第0列需要初始化
         for(int i=1;i<=n;i++){
            for(int j=0;j<=i+1;j++)
                f[i][j]=-INF;
        }
        int res=-INF;
        
        f[1][1]=a[1][1];
        
        for(int i=2;i<=n;i++){
            for(int j=1;j<=i;j++)
            {
                    f[i][j]= max(f[i-1][j-1]+a[i][j],f[i-1][j]+a[i][j]);
            }
                 
        }
        //结果在最后一行取
        for(int i=1;i<=n;i++) res=max(res,f[n][i]);
        cout<<res<<endl;
        
        
        
        
        
    }
    
    

    最小路径和

    Leetcode 64
    题目
    给定一个包含非负整数的 m x n 网格,请找出一条从左上角到右下角的路径,使得路径上的数字总和为最小。
    说明:每次只能向下或者向右移动一步。

    示例:

    输入:
    [
    [1,3,1],
    [1,5,1],
    [4,2,1]
    ]
    输出: 7
    解释: 因为路径 1→3→1→1→1 的总和最小。

    ac代码

    class Solution {
    public:
        int minPathSum(vector<vector<int>>& grid) {
            int m=grid.size();
            int n=grid[0].size();
            vector<vector<int>> f(m,vector<int>(n,0));//m*n的两维vector,全0
            //状态
             f[0][0]=grid[0][0];
            for(int i=1;i<n;i++)//第一行
                f[0][i]+=grid[0][i]+f[0][i-1];
                
            f[0][0]=grid[0][0];
            for(int i=1;i<m;i++)//第一列
                f[i][0]+=grid[i][0]+f[i-1][0];
            //转移
            for(int i=1;i<m;i++)
                for(int j=1;j<n;j++)
                     f[i][j]=grid[i][j]+min(f[i-1][j],f[i][j-1]);            
            return f[m-1][n-1];
    
        }
    };
    

    最长上升子序列(LIS)

    题目链接:Acwing895. 最长上升子序列
    问题描述
    一个数的序列bi,当b1 < b2 < … < bS的时候,我们称这个序列是上升的。对于给定的一个序列(a1, a2, …, aN),我们可以得到一些上升的子序列(ai1, ai2, …, aiK),这里1 <= i1 < i2 < … < iK <= N。比如,对于序列(1, 7, 3, 5, 9, 4, 8),有它的一些上升子序列,如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4,比如子序列(1, 3, 5, 8)。你的任务,就是对于给定的序列,求出最长上升子序列的长度。
    输入数据
    输入的第一行是序列的长度N(1<=N<=1000)。第二行给出的序列中的N个整数,这些整数的取值范围都是0-10000。
    输出要求
    最长上升子序列的长度。

    输入样例
    7
    1 7 3 5 9 4 8
    输出样例
    4

    分析
    求 a 1 _1 1,a 2 _2 2,…,a k _k k,…,a n _n n 的最长上升子序列
    子问题是求 a 1 _1 1,a 2 _2 2,…,a k _k k的最长上升子序列

    dp[i]表示终点是a i _i i 的最长上升子序列的长度
    动态规划

    1. 状态转移 : dp[ i ] = max { dp[ j ]+1 , dp[ i ] } , 对于所有的 j< i ,并且 f j _j j<f i _i i
      含义: 以a j _j j为终点的最长子序列长度加上 a i _i i本身 就是 以 a i _i i结尾的最长子序列的长度, 即 dp[ j ]+1
    2. base cases :dp[ i ] =1 ,i ∈ [0,n)
      含义:初始时每个位置的最长上升子序列长度都为1,即它本身

    时间复杂度 O(n 2 ^2 2)

    代码

    #include<iostream>
    using namespace std;
    
    const int maxn=1010;
    int f[maxn],dp[maxn];
    //dp[i]表示终点是i的最长上升子序列的长度 
    int ans=1;//保存结果 
    int main()
    {
    	int N;
    	cin>>N;
    	for(int i=1;i<=N;i++)
    	{
    		cin>>f[i];
    		dp[i]=1;//边界处理 
    	}
    
    	//转移 
    	for(int i=1;i<=N;i++)
    	{
    		for(int j=1;j<i;j++)
    		{
    			if(f[j]<f[i]) dp[i]=max(dp[i],dp[j]+1);
    		}		
    		ans=max(ans,dp[i]);
    	}
    	cout<<ans;		
    } 
    

    补充最长下降子序列(LDS)和最长上升子序列(LIS)分装成函数:

    #include<iostream>
    
    using namespace std;
    const int maxn=1010;
    
    long long a[maxn],dp[maxn];
    
    //最长下降子序列 
    long long LDS( long long a[],int N)
    {
    	long long  temp=0;
    	for(int i=1;i<=N;i++)
    	 dp[i]=1;
    	 for(int i=1;i<=N;i++)
    	 {
    	 	for(int j=1;j<i;j++)
    	 	{
    	 		if(a[j]>a[i])
    	 			dp[i]=max(dp[j]+1,dp[i]);
    	 	}
    	 	temp=max(dp[i],temp);
    	 }
    	 
    	 return temp;
    }
    //最长上升子序列 
    long long LIS( long long a[],int N)
    {
    	long long  temp=0;
    	for(int i=1;i<=N;i++)
    	 dp[i]=1;
    	 for(int i=1;i<=N;i++)
    	 {
    	 	for(int j=1;j<i;j++)
    	 	{
    	 		if(a[j]<a[i])
    	 			dp[i]=max(dp[j]+1,dp[i]);
    	 	}
    	 	temp=max(dp[i],temp);
    	 }
    	 
    	 return temp;
    }
    
    int main()
    {
    	
    	int N;
    	cin>>N;
    	for(int i=1;i<=N;i++) 
    		{
    			cin>>a[i];
    		}
    	cout<<LDS(a,N)<<endl;
    	cout<<LIS(a,N)<<endl; 
    }
    

    最长公共子序列(LCS)

    Leetcode1143. 最长公共子序列
    问题描述
    输入两个字符串, 要你求出两个字符串的最长公共子序列长度。
    输入
    输入两行不超过200的字符串。
    输出
    给出两个字符串的最大公共字符串的长度。

    样例输入
    abcfbc
    abfcab
    样例输出
    4

    分析
    状态转移
    我们需要看字符串 s1 第i个字母 和 字符串 s2 第j个字母的关系
    if s1 i _i i == s2 j _j j
    同时去掉各自最后的字母,看s1 i _i i- 1 _1 1 和 s2 j _j j- 1 _1 1
    得到 dp[ i ] [ j ] = dp [ i-1 ] [ j -1 ]+1

    if s1 i _i i != s2 j _j j
    若去掉 s1 i _i i ,看 s1 i _i i- 1 _1 1 和 s2 j _j j 的公共子序列 与
    若去掉 s2 j _j j,看s1 i _i i和 s2 j _j j- 1 _1 1的公共子序列
    取两者最大值 dp[ i ] [ j ] = max (dp [ i ] [ j-1 ],dp [ i-1] [ j ] );

    时间复杂度 O ( m × n ) O(m \times n) O(m×n),两个字符串的长度。

    代码

    class Solution {
    public:
        int longestCommonSubsequence(string text1, string text2) {
            int m=text1.size();
            int n=text2.size();
            int dp[m+1][n+1];
            
           memset(dp,0,sizeof(dp));//置零
            for(int i=1;i<=m;i++)
                for(int j=1;j<=n;j++)
                {
                    if(text1[i-1]!=text2[j-1])
                    dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
    
                    if(text1[i-1]==text2[j-1])
                    dp[i][j]=dp[i-1][j-1]+1;
                }
            return dp[m][n]; 
        }
    };
    

    板子题目链接:Acwing897. 最长公共子序列

    ac代码

    #include<bits/stdc++.h>
    using namespace std;
    
    const int N=1000;
    int n,m;
    int dp[N+1][N+1];
    int main(){
        string t1,t2;
        cin>>n>>m;
        cin>>t1>>t2;
       
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(t1[i-1]==t2[j-1])
                    dp[i][j]=dp[i-1][j-1]+1;
                else{
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                }
            }
            
        }
        cout<<dp[n][m]<<endl;
        
    }
    

    将字符串翻转成单增

    Leetcode 926
    如果一个由 ‘0’ 和 ‘1’ 组成的字符串,是以一些 ‘0’(可能没有 ‘0’)后面跟着一些 ‘1’(也可能没有 ‘1’)的形式组成的,那么该字符串是单调递增的。

    我们给出一个由字符 ‘0’ 和 ‘1’ 组成的字符串 S,我们可以将任何 ‘0’ 翻转为 ‘1’ 或者将 ‘1’ 翻转为 ‘0’。

    返回使 S 单调递增的最小翻转次数。

    示例 1:
    输入:“00110”
    输出:1
    解释:我们翻转最后一位得到 00111.
    示例 2:
    输入:“010110”
    输出:2
    解释:我们翻转得到 011111,或者是 000111。
    示例 3:
    输入:“00011000”
    输出:2
    解释:我们翻转得到 00000000。
    提示:
    1 <= S.length <= 20000
    S 中只包含字符 ‘0’ 和 ‘1’

    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/flip-string-to-monotone-increasing

    分析
    求最长不降子序列(LIS),字符串长度减去LIS 即可
    使用 DP算法求解LIS超时。

    超时代码(思路是对的)
    时间复杂度O( n 2 n^2 n2)

    class Solution {
    public:
        int minFlipsMonoIncr(string S) {
            int len=S.size();
            int dp[len+1];
            for(int i=0;i<=len;i++)
                dp[i]=1;
             int ans=0;
            for(int i=0;i<len;i++)
            {
                for(int j=0;j<i;j++)
                {
                    if(S[j]<=S[i])
                    dp[i]=max(dp[i],dp[j]+1);
                }
                ans=max(dp[i],ans);
            }
            return len-ans;
        }
         
    };
    

    优化代码(AC)
    维护单调数列,使用二分法。

    采用upper_bound()函数,返回第一个大于x的位置这样的话,遇到相等的元素,则一直会添加到数组中来
    时间复杂度O(nlogn)
    空间复杂度O(n)

    class Solution {
    public:
        int minFlipsMonoIncr(string S) {
            int len=S.size();
            vector<char> vec;
            for(int i=0;i<len;i++)
            {
                //p是大于S[i]的下标
                int p = upper_bound(vec.begin(),vec.end(),S[i])-vec.begin();
                if(vec.size()==p) //新来的是最大的
                    vec.push_back(S[i]);//加入数组
                else//新来的比原位置的小
                    vec[p]=S[i];替换掉
            }
           return len-vec.size();//返回字符串长度-LIS
        }
         
    };
    
    
    

    迷雾森林

    补充一道简单的dp题

    链接:迷雾森林
    来源:牛客网

    赛时提示:保证出发点和终点都是空地

    帕秋莉掌握了一种木属性魔法
    这种魔法可以生成一片森林(类似于迷阵),但一次实验时,帕秋莉不小心将自己困入了森林
    帕秋莉处于地图的左下角,出口在地图右上角,她只能够向上或者向右行走

    现在给你森林的地图,保证可以到达出口,请问有多少种不同的方案

    答案对2333取模

    输入描述:
    第一行两个整数m , n表示森林是m行n列
    接下来m行,每行n个数,描述了地图
    0 - 空地
    1 - 树(无法通过)
    输出描述:
    一个整数表示答案
    此题需要在计算过程中%2333,同时在处理边界的时候,出现1的话后面的都不能通过;这里处理是多用了一行的一个格,省掉了一行和一列的边界处理。

    #include<bits/stdc++.h>
    using namespace std;
    const int maxn=3010;
    
    int a[maxn][maxn];
    int n,m;
    long long  dp[maxn][maxn];
    
    
    template<class T>inline void read(T &res)
    {
    	char c;T flag=1;
    	while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;res=c-'0';
    	while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;
    }
    
    
    int main(){
    	cin>>m>>n;
    	for(int i=1;i<=m;i++){
    		for(int j=1;j<=n;j++)
    			read(a[i][j]);
    	}
    	memset(dp,0,sizeof(dp));
    	dp[m+1][1]=1;
    	
    	for(int i=m;i>=1;i--){
    		for(int j=1;j<=n;j++){
    			if(a[i][j]!=1)
    			dp[i][j]=(dp[i+1][j]+dp[i][j-1])%2333;
    		}
    	}
    	
    		cout<<dp[1][n]<<endl;
    //	cout<<endl;
    //	for(int i=1;i<=m;i++){
    //		for(int j=1;j<=n;j++)
    //			cout<<dp[i][j]<<" ";
    //		cout<<endl; 
    //	}
    	
    	
    
    	
    	
    }
    
    /*
    3 5
    0 1 0 0 0
    0 0 0 0 0
    0 0 1 0 0
    
    
    */
    

    感谢您阅读到最后,点击下面链接可轻松跳转。

    祝您阅读愉快。

    展开全文
  • DPB详解

    万次阅读 2020-03-15 08:27:34
    解码图像缓存器(decoded picture buffer,DPB)用于存放解码图像。DPB中既存在参考图像也存在非参考图像,那些不用于参考的图像输出后会被移除出DPB。 DPB的容量由SPS中的sps_max_dec_pic_buffering_minus1字段...

    解码图像缓存器(decoded picture buffer,DPB)用于存放解码图像。DPB中既存在参考图像也存在非参考图像,那些不用于参考的图像输出后会被移除出DPB。

    DPB的容量由SPS中的sps_max_dec_pic_buffering_minus1字段决定,HEVC中规定DPB容量最大为16。当DPB容量为1时,则其只能存储一帧当前解码图像,无法再存参考图像所以所有帧都必须使用帧内编码。

    DPB中有三类图像:非参考(non-reference)图像、短期参考( short-term)图像、长期参考( long-term)图像。

    DPB中图像状态变化如下:

    一幅图像解码后首先被初始化为短期参考图像。短期参考图像可以保持为短期参考图像或变为长期参考图像、非参考图像。长期参考图像可以保持为长期参考图像或变为非参考图像,但是不能变成短期参考图像。非参考图像不能变为参考图像。

    SPS中还有两个字段和DPB相关sps_max_num_reorder_picssps_max_latency_increase_plus1

    sps_max_num_reorder_pics表示解码顺序在某图像之前,而显示顺序在该图像之后的图像的最大数量。

    sps_max_latency_increase_plus1用于计算SpsMaxLatencyPictures表示显示顺序在某图像之前,而解码顺序在该图像之后的图像的最大数量。

    感兴趣的请关注微信公众号Video Coding

     

    展开全文
  • 区间dp入门

    万次阅读 多人点赞 2018-05-03 18:07:49
    什么是区间dp?顾名思义:区间dp就是在区间上进行动态规划,求解一段区间上的最优解。主要是通过合并小区间的 最优解进而得出整个大区间上最优解的dp算法。二.核心思路既然让我求解在一个区间上的最优解,那么我把这...
  • 状态压缩dp(状压dp)

    万次阅读 多人点赞 2018-07-16 09:05:43
    状压dp是一类比较难理解的dp; 在讲状压dp之前,我们应该清楚所有的dp是解决多阶段决策最优化问题的一种思想方法; 请注意多阶段这三个字: 经过前面三种背包的学习,可以发现如何定义状态是解决动态规划最重要的...
  • dp2px px2dp

    万次阅读 2017-01-19 15:45:29
    /** * 将dp转换成px * @param context * @param dpValue * @return */ public static int dip2px(Context context,float dpValue){ final float scale = context.getResources ().g
  • 安卓dp转px,px转dp方法

    万次阅读 2018-06-06 15:35:04
    dp转px: /** * 根据手机的分辨率从 dp 的单位 转成为 px(像素) */ public static int dip2px(Context context, float dpValue) { final float scale = context.getResources().getDisplayMetrics().densit...
  • miniDPDP 管脚定义的坑

    千次阅读 2021-01-21 13:35:39
    miniDPDP 管脚定义的坑 miniDPDP都是双排20pin,但管脚定义顺序完全不同,设计一定要避免。网上太难找到管脚定义,贴在这里。 标准DP(信号源端) |DP源端信号定义 管脚 名称 描述 1 LANE0+ 2 ...
  • 动态规划之树形DP,区间DP

    千次阅读 2019-07-19 20:38:51
    树形DP 树形 DP,即在树上进行的 DP。由于树固有的递归性质,树形 DP 一般都是递归进行的。 以下面这道题为例,介绍一下树形 DP 的一般过程。 https://www.luogu.org/problemnew/show/P1352 我们可以定义 dp[i][0/1...
  • DisplayPort-DP接口知识

    万次阅读 多人点赞 2019-05-23 10:38:45
    DP接口(DisplayPort)是一种图像显示接口,它不仅可以支持全高清显示分辨率(1920×1080),还能支持4k分辨率(3840×2160),以及最新的8k分辨率(7680×4320)。DP接口不仅传输率高,而且可靠稳定,其接口传输的信号由...
  • 本文档包括2015年发布的:《DP1.4标准(VESA Proposed DisplayPort (DP) Standard》866页,《DisplayPort和eDP物理层兼容性测试》,DisplayPort1.1-1.2-1.3-区别简介
  • dp计算

    千次阅读 2017-04-20 16:25:07
    1.首先什么是dp?什么是px?dp和px有什么区别?dp与px之间的转换关系? 1.什么px?图像显示的基本单元,我们知道屏幕是由很多点组成的,因为点特别小,所以我们看起来就像是一片的。那其中的每一个点就是像素点,而px呢...
  • DP概述和常见DP面试题 --算法竞赛专题解析(11)

    千次阅读 多人点赞 2020-04-11 10:18:09
    DP的概念和基本操作;DP的设计、方程推导、记忆化编码、递推编码、滚动数组;常见的DP面试题。
  • 对于这个历史遗留性问题每次回头处理起来着实让人头疼 解决方案有以下几种 1.张鸿洋已经实现了并且在githup上的Android...至于字体大小或者控件高度,工具满天飞的现在设计师连dp都会给你标号的,是个Android程序
  • 小白dp总结

    千次阅读 2020-10-11 21:33:28
    根据目前我所做的几个dp题的小总结 背包问题经过简化过就先不参与比较 背包总结 一下仅个人理解: 根据所求的不同dp数组代表不同含义 dp主要是填表的过程----->填表的顺序 由后面需要用到前面求出的值有关 冰水...
  • 数位dp

    万次阅读 2018-11-17 21:38:32
    数位dp是一种计数用的dp,一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp,字面意思就是在数位上进行dp咯。数位还算是比较好听的名字,数位的含义:一个数有个位、十位、百位、千位...
  • dp模式是什么意思 DP:显示图片 (DP: Display Picture) DP is an abbreviation of the Display Picture. It is also called a profile picture. It denotes a picture which is in commonly used as a display ...
  • NC 201607 DP

    千次阅读 2020-07-01 11:08:19
    题意 传送门 NC 201607 题解 题意其实是求节点 111 ...dp[i]=∑e(i,j)∈Edp[j]dp[i]=\sum\limits_{e(i,j)\in E} dp[j]dp[i]=e(i,j)∈E∑​dp[j] #include <bits/stdc++.h> using namespace std; #define maxn 100
  • DP-记录

    千次阅读 2020-08-11 17:11:07
    这里写自定义目录标题DP记录四字键盘对于不同的DP状态定义有不同的解法方法1:传统方法,暴力列举所有状态方法2:“贪心”+dp DP记录 四字键盘 即A,Crtl+A,Crtl+C,Crtl+V四种键盘,使用它们在一个啥也没有的空...
  • 数位DP入门+数位DP模板

    千次阅读 2017-08-20 11:58:20
    数位dp是一种计数用的dp,一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp,字面意思就是在数位上进行dp咯。数位还算是比较好听的名字,数位的含义:一个数有个位、十位、百位、千位......数的每...
  • 颜值与质量俱佳的4K miniDPDP线

    千次阅读 2019-06-13 11:25:28
    现在常见的DisplayPort和苹果开发的miniDP是号称目前业内最顶级的DP(DisplayPort)接口,DP接口起始标准发轫于2006年,由视频电子标准协会(VESA)全权制定。DisplayPort拥有全面超越HDMI的整体素质,重点在于它是...
  • 巧克力蛋糕 DP

    千次阅读 2020-03-15 17:14:42
    题目大意,现在有一个L高度的容器,还有三种巧克力:1.高1cm的黑巧克。2.高1cm的白巧克。...然后看了一下题解发现是dp(题解说是简单dp,但是我看了很久才懂)。 我们使用一个二维数组dp[max][5],其中...
  • Codeforces 1110D Jongmah dp

    万次阅读 2020-10-02 23:38:09
    可以发现同样三个数字组成的顺子不会超过三组(可以当作三个刻子处理),因此可以定义dp[i][j][k]dp[i][j][k]dp[i][j][k]表示前iii种牌,i−1,i,i+1i-1,i,i+1i−1,i,i+1组成的顺子数量为jjj,i,i+1,i+2i,i+1,i+2i,i+1,i+2...
  • DP83848官方原理图示例

    2018-09-17 18:05:32
    DP83848官方原理图示例 使用独立接口模式的网络模块。
  • 树形dp

    千次阅读 2018-08-15 19:26:11
    这是一种在树上的dp,它与线性dp不同,与线性dp的顺序是不同的所以其实树形dp就是 树上dp是一种在树状结构上进行dp的一种,各个阶段呈现树状关系的时候也可以采用树形dp。 2.分类 其实这里也有很多类了,树上...
  • 概率dp学习笔记+概率dp

    千次阅读 2018-08-19 10:32:49
    2.期望从后往前找,一般dp[n]=0,dp[0]是答案; 3.解决过程,找出各种情况乘上这种情况发生的概率,求和; 【1】A - Collecting Bugs 我是题目链接 题意:一个软件有s个子系统,会产生n种bug。 某人一天发现.....
  • DP_区间DP专辑】

    千次阅读 2013-04-13 17:11:50
    区间DP是一类在区间上进行动态规划的最优问题,一般是根据问题设出一个表示状态的dp,可以是二维的也可以是三维的,一般情况下为二维。然后将问题划分成两个子问题,也就是一段区间分成左右两个区间,然后将左右两个...
  • DP接口与HDMI接口的区别?

    万次阅读 2020-04-24 21:00:07
    DP接口与HDMI接口的区别? 一、dp接口 DisplayPort缩写DP,与目前主流的HDMI接口均属于数字高清接口,都支持一根信号线同时传输视频和音频信号,DP接口从第一代就达到了10.8Gbps带宽,支持2560 x 160012bit输出。 ...
  • 介绍了SIMATIC S7-300 Profibus通讯,中用于连接连个Profibus-DP主站网络的DP/DP Coupler使两个主站网络之间进行数据通讯。主要介绍了以下几个方面; 1、 DP/DP Coupler模块概述 2、组态在两个Profibus master网络中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 875,677
精华内容 350,270
关键字:

dp