chdy

jzyz 题库题目选做

题库中也有很多我想不出来的模拟赛的题目。做还是必要的。做自己的题目时间很紧想想自己的文化课我又没有那么强我必须得刷.

LINK：水题一道

发现是一道计数题计数题拿高分的才是王者，但是计数题不取模就是在耍流氓了...好久没写高精了顺便写写。

此题我们发现不管怎么搞每个教室都需要两个人我们不妨先让m-=2*n; 然后就是剩下的m个人的分配问题了感觉是组合数其实并不尽然。因为显然不对...

这样对于一个人来说他有n种可能那么m个人呢？m^n 但是显然有重复如第一个人选第二个第二个人选第一个和第一个人选第一个第二个人选第二个这样是等效的...

考虑排列数对我们答案的影响，不管排列的话其实除以一个m!即可。然后成功想错这样的做法是错误的。因为这有重复除以m!根本什么也不是。。。没有什么排列数...

正解是隔板法再次隔板设当前人数为 s=m-2*n 那么其实有将s个人分到n个房间中且每个房间总和为s 也就是说 x1+x2+x3+x4+...=s 这显然是隔板法了...

注意到x可能为0 所以再补板n-1 空隙还是插板n-1个即可。m为500 用头想都是高精。C(s+n-1,n-1) 。。。想10min都没怎么发现这个模型藏得有点深。

约分是必要的分解质因数再约分就变成高精乘单精了。

//#include
#include
#include
#include 
#include
#include<string>
#include
#include
#include
#include
#include
#include
#include
#include
#include<set>
#include
#include
#include
#include
#define ll long long
using namespace std;
char buf[1<<15],*fs,*ft;
inline char getc()
{
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;
}
inline int read()
{
    int x=0,f=1;char ch=getc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getc();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
    return x*f;
}
const int MAXN=1010;
int s0,s1,s2;
int p0[MAXN],p1[MAXN],p2[MAXN];
int b[MAXN],top;
int n,m,s,c;
inline void insert(int x,int *a)
{
    int s=x;
    for(int i=2;i*i<=x;++i)
        while(s%i==0)
        {
            s=s/i;
            ++a[i];
        }
    if(s>1)++a[s];
}
inline void mul(int x)
{
    int res=0;
    for(int i=1;i<=top;++i)
    {
        b[i]=b[i]*x;
        b[i]+=res;
        res=b[i]/10;
        b[i]=b[i]%10;
    }
    while(res)
    {
        b[++top]=res;
        res=b[top]/10;
        b[top]=b[top]%10;
    }
}
int main()
{
    //freopen("1.in","r",stdin);
    n=read();m=read();
    if(m<2*n){puts("0");return 0;}
    s=m-2*n+n-1;c=n-1;//求 C(s,c);
    for(int i=2;i<=s;++i)insert(i,p0);
    for(int i=2;i<=c;++i)insert(i,p1);
    for(int i=2;i<=s-c;++i)insert(i,p2);
    b[++top]=1;
    for(int i=2;i<=s;++i)
    {
        p0[i]=p0[i]-p1[i]-p2[i];
        while(p0[i])
        {
            --p0[i];
            mul(i);
        }
    }
    for(int i=top;i>=1;--i)printf("%d",b[i]);
    return 0;
}

View Code

LINK：免费馅饼

咕了这么长时间了也该写写了... 看起来很显然是dp 但是还要输出方案...（那也很水

第一次写状态转移写错了，惊了瞎写了一个状态转移..感觉不太对..当然f[i][j]表示第i秒到了第j个位置的最大价值 f[i][j]=max(f[i-1][j-1],f[i-1][j-2]...)然后馅饼的话开vector记录下来，到达这个位置就累加上价值即可。

有一个坑点是对于一个馅饼下降高度为 h-1 题目中说道恰好在某一秒末和人相遇才行也就是 h-1%v!=0的都不能要。还有一个坑点是方案要从最后一个馅饼开始找而不是最后一秒开始...

//#include
#include
#include
#include
#include
#include<string>
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include<set>
#include
#include
#define INF 1000000000
#define ll long long
#define R register
#define db double
#define max(x,y) ((x)>(y)?(x):(y))
using namespace std;
char buf[1<<15],*fs,*ft;
inline char getc()
{
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;
}
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN=110,maxn=2010;
int n,m,cnt,maxx,ans;
int st[MAXN],top;
struct wy
{
    int s,x,v,p;
}t[maxn];
int f[maxn][MAXN];//f[i][j]表示第i秒在x这个位置所能获得的最大分数
int w[maxn][MAXN];
vector<int>g[maxn];
inline int abs(int x){return x>0?x:-x;}
inline void get_path(int x,int y)
{
    if(!x)return;
    st[++top]=-(w[x][y]-y);
    get_path(x-1,w[x][y]);
}
int main()
{
    //freopen("1.in","r",stdin);
    n=read();m=read();
    int s,x,v,p,h=m;--h;
    while(scanf("%d",&s)==1)
    {
        x=read();v=read();p=read();
        if(h%v!=0)continue;
        t[++cnt]=(wy){s,x,v,p};
        int st=s+h/v;
        g[st].push_back(cnt);
        maxx=max(maxx,st);
    }
    memset(f,0xcf,sizeof(f));
    f[0][(n>>1)+1]=0;
    for(int i=1;i<=maxx;++i)
    {
        for(int j=1;j<=n;++j)
        {
            for(int k=max(1,j-2);k<=min(n,j+2);++k)
            {
                if(f[i][j]1][k])
                {
                    f[i][j]=f[i-1][k];
                    w[i][j]=k;
                }
            }
        }
        for(int k=0;k<(int)g[i].size();++k)
            {
                int r=g[i][k];
                f[i][t[r].x]+=t[r].p;
            }
    }
    for(int i=1;i<=n;++i)ans=max(ans,f[maxx][i]);
    printf("%d\n",ans);
    for(int i=1;i<=maxx;++i)
    {
        for(int j=1;j<=n;++j)
        {
            if(f[i][j]==ans)
            {
                get_path(i,j);
                for(int k=top;k>=1;--k)printf("%d\n",st[k]);
                return 0;
            }
        }
    }
    return 0;
}

View Code

update ：其实这个也可以不用vector存我们利用排序后时间从大到小的顺序便利整个数组即可省掉空间和时间...

LINK：字符合并

早就想写这道题了受不了了这道题是水题..我坚信。(然后想了30min 被打脸...

还是字符串之间进行合并值得一提的是这次只有01串每k个字符可以合成一个字符存在一个命题是如果(n-1)%(k-1)==0的话那么则有最后合并剩下一个字符 (我也不知道是怎么证明的..

首先还是设计状态吧反正是区间dp 转移着实有点困难但在我坚持不懈的努力之下还是成功的进行转移了但是不知道对不对感觉正确性还是有的..

f[i][j][k]表示由i到j状态为k的最大代价那么转移就是区间dp 然后枚举断点唯一不同的是还需要枚举左边状态s1 右边状态s2 然后merge一下即可 merge有点难写但是仔细思考还是可以O(1)的...

但是这样的复杂度是n^3*2^k*2^k=n^3*4^k; 显然过不了1e12 。

这里先放暴力（我不知道对不对不想交）:发现暴力是瞎写的不放了

当然我觉得这个merge写的还算很精辟/cy.(精辟锤子写错了。

考虑优化一个比较显然的地方是每次我们枚举状态的时候其实不必要枚举到1<<(k-1) 因为对于一个区间来说其固定的状态大小是存在的 (n-1)%(k-1)+1其实就是这个东西了...每8次一循环每个循环的复杂度是2^1-1+2^2-1+...2^7-1加起来是2^8那么这样其实复杂度骤降8倍..

还有一个不太明显的优化是进行状态合并的时候如果没有合成也就是不到k个字符的合成左边合成和右边合成其实都是等效的所以我们可以省掉右边的合并钦定左边进行合并即可。

那么就是我们只在乎右边合成了1或者0 至于更多的可以不管交给左边去合成即可。这样复杂度降为n^3*2^k/8 可以calc一下发现可以过了.

这样对于左边的状态我们还是可以利用(n-1)%(k-1)这个东西来剪枝。

那么这道题也就做完了我看了一眼书才发现的解法我也没想到第二个优化可能脑子有点乱..以后dp的时候要清醒别看书或看题解..这点小优化还是可以想出来的我觉得。

一直wa 发现是合并的时候没有判断准确合并的大小和长度不是随便合并的 0000和1可以合并但是状态得自己看有的时候0 可能代表着0000什么的我忽略了这一点。

当然得开long long 题目描述不清楚当然全部开long long会T (我真不容易写一道题。注意不要全开long long 常数是int的两倍于是把for里的改成int就过了。

//#include
#include
#include
#include
#include
#include<string>
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include<set>
#include
#include
#define INF 1000000000
#define ll long long
#define R register
#define db double
#define max(x,y) ((x)>(y)?(x):(y))
using namespace std;
char buf[1<<15],*fs,*ft;
inline char getc()
{
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;
}
inline ll read()
{
    ll x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN=301,maxn=8;
ll n,k,ans;
int a[MAXN],p[1<<maxn];
int s[1<<maxn];
ll f[MAXN][MAXN][1<<maxn];
//f[i][j][k] 表示由区间i到区间j合成后状态为k的最大值
signed main()
{
    //freopen("1.in","r",stdin);
    n=read();k=read();
    memset(f,0xcf,sizeof(f));
    for(int i=1;i<=n;++i)a[i]=read(),f[i][i][a[i]]=0;
    for(int i=0;i<(1<i)
        s[i]=read(),p[i]=read();
    for(int len=2;len<=n;++len)
    {
        for(int i=1;i<=n-len+1;++i)
        {
            int j=i+len-1;
            for(int l=i;ll)
            {
                int len2=j-l;
                if((len2-1)%(k-1))continue;
                int len1=l-i+1;
                len1=(len1-1)%(k-1)+1;
                for(int s1=0;s1<(1<s1)
                {
                    if(f[i][l][s1]<0)continue;
                    if(f[l+1][j][0]>=0)
                    {
                        int state=s1<<1;
                        if(len1==k-1)
                            f[i][j][s[state]]=max(f[i][j][s[state]],f[i][l][s1]+f[l+1][j][0]+p[state]);
                        else
                            f[i][j][state]=max(f[i][j][state],f[i][l][s1]+f[l+1][j][0]);
                    }
                    if(f[l+1][j][1]>=0)
                    {
                        int state=s1<<1|1;
                        if(len1==k-1)
                            f[i][j][s[state]]=max(f[i][j][s[state]],f[i][l][s1]+f[l+1][j][1]+p[state]);
                        else
                            f[i][j][state]=max(f[i][j][state],f[i][l][s1]+f[l+1][j][1]);
                    }
                }
            }
        }
    }
    for(int i=0;i<(1<<(k-1));++i)
        ans=max(ans,f[1][n][i]);
    printf("%lld\n",ans);
    return 0;
}

View Code

LINK：分数规划生成树

其实就是想让我们找出一个最小的生成树罢了，直接prim会比克鲁斯卡尔快一点。注意这里需要二分一下比值因为我们不好直接求出这个比值。
所以考虑先二分，然后权值就有了我们想办法让mid减小的那个方式生成树即可。

//#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include<string>
#include
#include
#include
#include
#include
#include<set>
#include
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)>(y)?(y):(x))
#define INF 1000000000
#define ll long long
#define db double
#define EPS 1e-4
#define mp make_pair
#define F first
#define S second
using namespace std;
char buf[1<<15],*fs,*ft;
inline char getc()
{
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;
}
inline int read()
{
    int x=0,f=1;char ch=getc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getc();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
    return x*f;
}
const int MAXN=1010;
int n;
struct wy
{
    int x,y,z;
}t[MAXN];
int vis[MAXN];
db a[MAXN][MAXN],d[MAXN];
priority_queueint> > q;
inline int abs(int x){return x<0?-x:x;}
inline db dis(int x,int y)
{
    return sqrt(1.0*(t[x].x-t[y].x)*(t[x].x-t[y].x)+1.0*(t[x].y-t[y].y)*(t[x].y-t[y].y));
}
inline int check(db w)
{
    db ans=0;
    for(int i=1;i<=n;++i)d[i]=INF*1.0,vis[i]=0;
    q.push(mp(0,1));
    while(q.size())
    {
        int x=q.top().S;
        if(vis[x])
        {
            q.pop();
            continue;
        }
        ans=ans-q.top().F;
        vis[x]=1;
        for(int i=1;i<=n;++i)
        {
            if(vis[i])continue;
            db dd=abs(t[x].z-t[i].z)-a[x][i]*w;
            if(d[i]>dd)
            {
                d[i]=dd;
                q.push(mp(-d[i],i));
            }
        }
    }
    if(ans<=0)return 1;
    return 0;
}
int main()
{
    //freopen("1.in","r",stdin);
    n=read();
    for(int i=1;i<=n;++i)
    {
        int x,y,z;
        x=read();y=read();z=read();
        t[i]=(wy){x,y,z};
    }
    for(int i=1;i<=n;++i)
        for(int j=i+1;j<=n;++j)
            a[i][j]=a[j][i]=dis(i,j);
    db l=0,r=100;
    while(l+EPS<r)
    {
        db mid=(l+r)/2;
        if(check(mid))r=mid;
        else l=mid;
    }
    printf("%.3lf",l);
    return 0;
}

View Code

LINK：pigs有点神奇的题目看起来很复杂但其实我还真不会我有一个做法是拆点然后对于每个人都做一次最大流但是还是无法实现猪交换的时候的合法性。

做法比较强大是这样的我们很难完成在存在牛的点的情况下实现牛之间的交换因为考虑这个顺序比较难以控制可能较早的点会用较晚的点的边所以这很不好写，我们不妨不建牛点把牛放到一块然后表示牛可以任意互换，这样就不会出现上述情况了。综上我们每次都将一堆牛直接连向一个人如果下次还有人连相同的牛的话就把上次连的人连向当前这个人即可。

//#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include<string>
#include
#include
#include
#include
#include
#include<set>
#include
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)>(y)?(y):(x))
#define INF 1000000000
#define ll long long
#define db double
#define mp make_pair
using namespace std;
char buf[1<<15],*fs,*ft;
inline char getc()
{
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;
}
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getc();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
    return x*f;
}
const int MAXN=1010;
int n,m,S,T,ans,len=1,t,h;
int a[MAXN],b[MAXN];
int lin[MAXN],nex[MAXN*100<<1],ver[MAXN*100<<1],e[MAXN*100<<1];
int q[MAXN],vis[MAXN],cur[MAXN];
inline void add(int x,int y,int z)
{
    ver[++len]=y;nex[len]=lin[x];lin[x]=len;e[len]=z;
    ver[++len]=x;nex[len]=lin[y];lin[y]=len;e[len]=0;
}
inline int bfs()
{
    h=t=0;
    for(int i=1;i<=T;++i)vis[i]=0,cur[i]=lin[i];
    q[++t]=S;vis[S]=1;
    while(h++<t)
    {
        int x=q[h];
        for(int i=lin[x];i;i=nex[i])
        {
            int tn=ver[i];
            if(!e[i]||vis[tn])continue;
            vis[tn]=vis[x]+1;
            q[++t]=tn;
            if(tn==T)return 1;
        }
    }
    return 0;
}
inline int dinic(int x,int flow)
{
    if(x==T)return flow;
    int rest=flow,k;
    for(int i=cur[x];i&&rest;i=nex[i])
    {
        int tn=ver[i];
        cur[x]=i;
        if(vis[tn]==vis[x]+1&&e[i])
        {
            k=dinic(tn,min(flow,e[i]));
            if(!k){vis[tn]=0;continue;}
            e[i]-=k;e[i^1]+=k;rest-=k;
        }
    }
    return flow-rest;
}
int main()
{
    //freopen("1.in","r",stdin);
    m=read();n=read();
    S=n+1;T=S+1;
    for(int i=1;i<=m;++i)a[i]=read();
    for(int i=1;i<=n;++i)
    {
        int x=read(),cnt=0;
        for(int j=1;j<=x;++j)
        {
            int y=read();
            if(b[y])add(b[y],i,INF);
            else cnt+=a[y];
            b[y]=i;
        }
        x=read();
        add(S,i,cnt);
        add(i,T,x);
    }
    int flow=0;
    while(bfs())while((flow=dinic(S,INF)))ans+=flow;
    printf("%d\n",ans);
    return 0;
}

View Code

LINK：足球积分看起来是个贪心。其实应该就是贪心了。很简单对于求最大值我们能赢就赢不要平局因为赢得话比平局得分高。

输的话刚好相反分类讨论一下即可。想了一下求最小值还真的有很大的难度思考良久发现把所有情况搞出来取最小值即可。

很不错的贪心虽然wa了很多次下次在提交之前应该手玩一些数据才对。细节有点ex 不过剩下的就没什么了。

//#include
#include
#include
#include
#include
#include<string>
#include
#include
#include
#include
#include
#include
#include
#include<set>
#include
#include
#include
#include
#include
#define INF 1000000010
#define min(x,y) ((x)>(y)?(y):(x))
#define max(x,y) ((x)>(y)?(x):(y))
#define mp make_pair
#define ll long long
using namespace std;
char *fs,*ft,buf[1<<15];
inline char getc()
{
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;
}
inline ll read()
{
    ll x=0,f=1;char ch=getc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getc();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
    return x*f;
}
const ll MAXN=100010,maxn=MAXN<<1;
ll x,y,n;
ll ans,ans1;
signed main()
{
    //freopen("1.in","r",stdin);
    while(scanf("%d%d%d",&x,&y,&n)==3)
    {
        ans=ans1=0;
        ll xx=x,yy=y,nn=n;
        if(n==1)
        {
            if(x>y)ans=ans1=3;
            if(x==y)ans=ans1=1;
            printf("%lld %lld\n",ans,ans1);
            continue;
        }
        //先求最大值
        ll w=n-1;
        ll v=min(w,x);
        ans+=v*3;
        w-=v;
        x-=v;
        if(x>y)ans+=3;
        if(x==y)++ans;
        ans+=w;
        printf("%lld ",ans);
        //再求最小值
        if(xx>yy)
        {
            ans1+=3;
            --nn;
            v=min(yy,nn);
            nn-=v;
            ans1+=nn;
            printf("%lld\n",ans1);
            continue;
        }
        --nn;
        if(xx==yy)
        {
            if(nn>=3&&yy>=3)
            {
                ans1+=3;
                v=min(yy,nn);
                nn-=v;
                ans1+=nn;
                printf("%lld\n",ans1);
            }
            else
            {
                ++ans1;
                ans1+=nn;
                printf("%lld\n",ans1);
            }
        }
        else//对于 xx
        {
            ll w1=3,w2=1,w3=0;
            w1=w1+(nn-min(nn,yy));
            yy-=xx;
            w2=w2+(nn-min(nn,yy));
            --yy;
            w3=w3+(nn-min(nn,yy));
            ans1=min(w1,w2);
            ans1=min(ans1,w3);
            printf("%lld\n",ans1);
        }
    }
    //cout<
    return 0;
}

View Code

LINK：背包的方案数问题。求不适用第一个物品且装满背包的方案数再求不用第二个物品的方案数一直求到第n个？

一个比较显然的思路是暴力 n^2m的暴力考虑优化这个过程。考虑我们每次把有用的东西保存下来。也就是说我们先对整体进行一次01背包方案数然后想办法求出第一个除去第一个物品的方案数观察把dp式加法换成减法即可。考虑一下实际的意义。

我们先广义的分析：做背包和物品的顺序无关所以我们可以想象成第一个物品是最后一个加进去的所以可以看出这样的做法显然正确。

狭义的想：这很显然。

当时我写的无脑暴力还是保存一下吧。

#include
#include
#include
#include
#include<string>
#include
#include
#include
#include
#include
#include
#include
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int maxn=1014;
int n,m;
int w[maxn],f[10007],ans=0;
int main()
{
    //freopen("1.in","r",stdin);
    n=read();m=read();
    for(int i=1;i<=n;i++)w[i]=read(),ans+=w[i];
    f[0]=1;
    for(int k=1;k<=n;k++)
    {
        memset(f,0,sizeof(f));
        f[0]=1;
        for(int i=1;i<=n;i++)
        {    
            if(ans-w[i]break;
            for(int j=m;j>=w[i];j--)
            {    
                    if(i==k)continue;
                    f[j]=(f[j]%maxn+f[j-w[i]]%maxn)%maxn;
            }
        }
        printf("%d ",f[m]%maxn);
        if(k==n)printf("\n");
    }
    return 0;
}

View Code

这是很顺利的倒序背包清空一下即可。

//#include
#include
#include
#include
#include
#include<string>
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include<set>
#include
#include
#define INF 1000000010
#define ll long long
#define mp(x,y) make_pair(x,y)
#define un unsigned
#define db double
#define EPS 1e-5
#define mod 1014
using namespace std;
char buf[1<<15],*fs,*ft;
inline char getc()
{
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;
}
inline int read()
{
    int x=0,f=1;char ch=getc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getc();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
    return x*f;
}

const int MAXN=10010;
int n,m;
int a[MAXN],f[MAXN],w[MAXN];
int main()
{
    //freopen("FILE.in","r",stdin);
    //freopen("FILE.out","w",stdout);
    n=read();m=read();
    f[0]=1;
    for(int i=1;i<=n;++i)a[i]=read();
    for(int i=1;i<=n;++i)
        for(int j=m;j>=a[i];--j)
            f[j]=(f[j]+f[j-a[i]])%mod;
    //for(int i=1;i<=m;++i)cout<
    for(int i=1;i<=n;++i)
    {
        if(m"%d\n",f[m]);continue;}
        for(int j=0;j<=m;++j)w[j]=f[j];
        for(int j=a[i];j<=m;++j)f[j]=(f[j]-f[j-a[i]])%mod;
        printf("%d ",((f[m]+mod)%mod));
        for(int j=0;j<=m;++j)f[j]=w[j];
    }
    return 0;
}

View Code

LINK：最大速度中级搜索。这题搜索起来比较麻烦。

由于到达每个点还有方向考虑把方向也存起来考虑dij 开跑但是连续转两次也算掉头所以还不免记录上次左转还是右转。

注意大根堆别写错方向别搞错预处理要仔细 dij 换成spfa 我们发现有状态都是0 但是一个0状态能更新一个0状态所以只能spfa了..

//#include
#include
#include
#include
#include
#include<string>
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include<set>
#include
#include
#define INF 1000000010
#define ll long long
#define mp(x,y) make_pair(x,y)
#define un unsigned
#define db double
#define EPS 1e-5
#define mod 1014
using namespace std;
char buf[1<<15],*fs,*ft;
inline char getc()
{
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;
}
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int MAXN=31;
int st,en,op,s1,s2,vv,n,m,cnt,ans;
int dx[5]={0,1,-1,0,0};
int dy[5]={0,0,0,1,-1};
int f[MAXN][MAXN][5],fa[MAXN*MAXN];
int vis[MAXN][MAXN][5],id[MAXN][MAXN];
int d[5][5][2],v[5][5],g[5][5];
struct wy
{
    int x,y,op;
    int v,pre;
    int friend operator <(wy a,wy b)
    {
        return a.v<b.v;
    }
};
char a[MAXN][MAXN];
priority_queue q;
inline int getfather(int x){return x==fa[x]?x:fa[x]=getfather(fa[x]);}
inline void bfs()
{
    while(q.size())
    {
        wy s=q.top();q.pop();
        //if(vis[s.x][s.y][s.op])continue;
        //vis[s.x][s.y][s.op]=1;
        for(int i=1;i<=4;++i)
            {
                int xx=s.x+d[s.op][i][0];
                int yy=s.y+d[s.op][i][1];
                if(xx<1||yy<1||xx>n||yy>m)continue;
                if(a[xx][yy]=='.')continue;
                int w=max(0,s.v+v[s.op][i]);
                if(g[s.op][i]==s.pre&&s.pre>0)w=0;
                if(f[xx][yy][i]<w)
                {
                    f[xx][yy][i]=w;
                    q.push((wy){xx,yy,i,w,g[s.op][i]});
                }
            }
    }
}
int main()
{
    //freopen("1.in","r",stdin);
    n=read();m=read();vv=read();
    memset(f,0xcf,sizeof(f));
    for(int i=1;i<=n;++i)
    {
        scanf("%s",a[i]+1);
        for(int j=1;j<=m;++j)
        {
            id[i][j]=++cnt;fa[cnt]=cnt;
            if(a[i][j]!='.'&&a[i][j]!='#'&&a[i][j]!='F')
            {
                if(a[i][j]=='E')op=1;
                if(a[i][j]=='W')op=2;
                if(a[i][j]=='N')op=3;
                if(a[i][j]=='S')op=4;
                st=i,en=j;
            }
            if(a[i][j]=='F')s1=i,s2=j;
        }
    }
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
        {
            if(a[i][j]=='.')continue;
            for(int k=1;k<=4;++k)
            {
                int x=i+dx[k];
                int y=j+dy[k];
                if(x<1||y<1||x>n||y>m)continue;
                if(a[x][y]=='.')continue;
                int xx=getfather(id[x][y]);
                int yy=getfather(id[i][j]);
                fa[xx]=yy;
            }
        }
    if(getfather(fa[id[st][en]])!=getfather(fa[id[s1][s2]]))
    {
        puts("-1");return 0;
    }
    f[st][en][op]=vv;
    d[1][1][0]=0;d[1][1][1]=1;v[1][1]=1;g[1][1]=0;
    d[1][2][0]=0;d[1][2][1]=0;v[1][2]=-INF;g[1][2]=-1;
    d[1][3][0]=0;d[1][3][1]=0;v[1][3]=-35;g[1][3]=1;//向左
    d[1][4][0]=0;d[1][4][1]=0;v[1][4]=-40;g[1][4]=2;//向右
    
    d[2][1][0]=0;d[2][1][1]=0;v[2][1]=-INF;g[2][1]=-1;
    d[2][2][0]=0;d[2][2][1]=-1;v[2][2]=1;g[2][2]=0;
    d[2][3][0]=0;d[2][3][1]=0;v[2][3]=-40;g[2][3]=2;
    d[2][4][0]=0;d[2][4][1]=0;v[2][4]=-35;g[2][4]=1;
    
    d[3][1][0]=0;d[3][1][1]=0;v[3][1]=-40;g[3][1]=2;
    d[3][2][0]=0;d[3][2][1]=0;v[3][2]=-35;g[3][2]=1;
    d[3][3][0]=-1;d[3][3][1]=0;v[3][3]=1;g[3][3]=0;
    d[3][4][0]=0;d[3][4][1]=0;v[3][4]=-INF;g[3][4]=-1;
    
    d[4][1][0]=0;d[4][1][1]=0;v[4][1]=-35;g[4][1]=1;
    d[4][2][0]=0;d[4][2][1]=0;v[4][2]=-40;g[4][2]=2;
    d[4][3][0]=0;d[4][3][1]=0;v[4][3]=-INF;g[4][3]=-1;
    d[4][4][0]=1;d[4][4][1]=0;v[4][4]=1;g[4][4]=0;
    q.push((wy){st,en,op,vv,-2});
    bfs();
    for(int i=1;i<=4;++i)ans=max(ans,f[s1][s2][i]);
    printf("%d\n",ans);
    return 0;
}

View Code

芦花鞋一四许叶晗
又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
2020-01-25 晴岚85
郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
一百九十四章. 自相矛盾巨木擎天
唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
开心蒋泳频
从无比抗拒来上课到接受，感动，收获～看着波哥成长，晶晶幸福笑容满面。感觉自己做的事情很有意义，很开心！还有3个感召目标就是还有三个有缘人，哈哈。明天感召去明日计划：8：30-11：00小公益11：00-21点上班，感召图片发自App图片发自App图片发自App
我的烦恼余建梅
我的烦恼。女儿问我：“你给学生布置什么作文题目？”“《我的烦恼》。”“他们都这么大了，你觉得他们还有烦恼吗？”“有啊！每个人都会有自己烦恼。”“我不相信，大人是没有烦恼的，如果说一定有的话，你的烦恼和我写作业有关，而且是小烦恼。不像我，天天被你说，有这样的妈妈，烦恼是没完没了。”女儿愤愤不平。每个人都会有自己的烦恼，处在上有老下有小的年纪，烦恼多的数不完。想干好工作带好孩子，想孝顺父母又想经营好自
放下是一段成长的修行小莳玥
人来到这个世界上，只有两件事：生和死。一件事已经做完了，另一件你还急什么呢?是人，都有七情六欲。是心，都有喜怒哀乐，这些再正常不过了。别总抱怨自己活得累，过得辛苦。永远记住：舒坦是留给死人的。苦，才是生活；累，才是工作；变，才是命运；忍，才是历练；容，才是智慧；静，才是修养；舍，才会得到；做，才会拥有。人生，活得太清楚，才是最大的不明白。有些事，看得很清，却说不清；有些人，了解很深，却猜不透；有些
活给自己看，笑容才灿烂听着了么
白岩松说“有时候，我们活得很累，并非生活过于刻薄，而是我们太容易被外界的氛围所感染，被他人的情绪所左右。”心情是自己的。若只是活在别人的眼里、嘴里，便掌握不了让自己开心的主动权。人活着，不是为了活给别人看的，唯有做最真实的自己，活给自己看，笑容才灿烂。诚然，世事纷繁复杂，人人都有一张嘴，管也管不了。永远有人欣赏你，也永远有人批评你，不可能做到让所有人都满意，开心做自己才是最重要的。人生苦短，有太多
每日一题——第八十九题互联网打工人no1 C语言程序设计每日一练 c语言
题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
每日一题——第九十题互联网打工人no1 C语言程序设计每日一练 c语言
题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
每日一题——第八十四题互联网打工人no1 C语言程序设计每日一练 c语言
题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
每日一题——第八十二题互联网打工人no1 C语言程序设计每日一练 c语言
题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
每日一题——第八十三题互联网打工人no1 C语言程序设计每日一练 c语言
题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
网易严选官方旗舰店，优质商品，卓越服务高省_飞智666600
网易严选官方旗舰店是网易旗下的一家电商平台，以提供优质商品和卓越服务而闻名。作为一名SEO优化师，我将为您详细介绍网易严选官方旗舰店，并重点强调其特点和优势。大家好！我是高省APP最大团队&联合创始人飞智导师。相较于其他返利app，高省APP的佣金更高，模式更好，最重要的是，终端用户不会流失！高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
关于提高复杂业务逻辑代码可读性的思考编程经验分享开发经验 java 数据库开发语言
目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
读《人世间》有感一0一
这个寒假，就如同朋友圈中的一段话：一闭眼，一睁眼假期还有5天，在一闭眼一睁眼假期还有12天；再一闭眼一睁眼假期还有20天；不敢睡，不敢睡啊……受疫情影响，这个假期变得漫长又煎熬，我也无时无刻不关注着疫情的变化。当然这样的一个假期，我还真得要感谢周翔，因为他有个爱看书的习惯，所以家里有不少他看过的书，可以让我随意挑选，因此也让我的假期不至于那么无所事事。这次我选了一本梁晓声的《人世间》，作为一名语文
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
想明白这个问题，你才能写下去文自拾
春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
2.0践行没有你的参与就不完美 x秀丽x
亲爱的伙伴们早上好，今天早上我们开了一次班委竞选的会议，全程只有20多个人参与，宫班本着对大家负责任的态度告诉我们，此次竞选作废，原因是这没有达到2.0的100%参会要求，如果没有大家的参与那么这个班委选出来还有什么意义，这说明选出来的人也是不一定是我们大家心目中认可的那个人，所以为了让大家的这个90天能够更好的激发出自己的的“做”的能力，那么要从第一次竞选班委的会议开始做到100%出席会议，竞选
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
阶段总结反思轻争
马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
冬天短期的暴利小生意有哪些？那些小生意适合新手做？一起高省
短期生意不失为创业的一个商机，不过短期生意的商机是转瞬即逝的，而且这类生意也很难作为长期的生意去做，那冬天短期暴利小生意查看更多关于短期暴利小生意的文章有哪些呢?给大家先推荐一个2023年风口项目吧，真很不错的项目，全程零投资，当做副业来做真的很稳定，不管你什么阶层的人，或多或少都网购吧？你们知道网购是可以拿提成，拿返利，拿分佣的吗？你们知道很多优惠券群里面，天天群主和管理发一些商品吗？他们其实在
怎么做淘客赚钱(2022最新免费淘客盈利的方法) 高省_飞智666600
很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）算法大师华为od 面试 python 算法前端
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
每日一题——第八十八题互联网打工人no1 C语言程序设计每日一练 c语言
题目：输入一个9位的无符号整数，判断其是否有重复数字#include#include#includeintmain(){charnum_str[10];printf("请输入一个9位数的无符号数：");scanf_s("%9d",&num_str);if(strlen(num_str)!=9){printf("输入的不是一个9位无符号整数，请重新输入");}else{if(hasDuplicate
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
LeetCode[Math] - #66 Plus One Cwind java LeetCode 题解 Algorithm Math
原题链接：#66 Plus One 要求：给定一个用数字数组表示的非负整数，如num1 = {1, 2, 3, 9}, num2 = {9, 9}等，给这个数加上1。注意： 1. 数字的较高位存在数组的头上，即num1表示数字1239 2. 每一位（数组中的每个元素）的取值范围为0~9 难度：简单分析：题目比较简单，只须从数组
JQuery中$.ajax()方法参数详解 AILIKES JavaScript jsonp jquery Ajax json
url: 要求为String类型的参数，（默认为当前页地址）发送请求的地址。 type: 要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和 delete也可以使用，但仅部分浏览器支持。 timeout: 要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局
JConsole & JVisualVM远程监视Webphere服务器JVM Kai_Ge JVisualVM JConsole Webphere
JConsole是JDK里自带的一个工具，可以监测Java程序运行时所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。我们可以根据这些信息判断程序是否有内存泄漏问题。　　使用JConsole工具来分析WAS的JVM问题，需要进行相关的配置。　　首先我们看WAS服务器端的配置. 　　1、登录was控制台https://10.4.119.18
自定义annotation 120153216 annotation
Java annotation 自定义注释@interface的用法一、什么是注释说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。而J2SE5.0中提供的注释就是java源代码的元数据，也就是说注释是描述java源
CentOS 5/6.X 使用 EPEL YUM源 2002wmj centos
CentOS 6.X 安装使用EPEL YUM源1. 查看操作系统版本[root@node1 ~]# uname -a Linux node1.test.com 2.6.32-358.el6.x86_64 #1 SMP Fri Feb 22 00:31:26 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux [root@node1 ~]#
在SQLSERVER中查找缺失和无用的索引SQL 357029540 SQL Server
--缺失的索引 SELECT avg_total_user_cost * avg_user_impact * ( user_scans + user_seeks ) AS PossibleImprovement , last_user_seek ,
Spring3 MVC 笔记（二） —json+rest优化 7454103 Spring3 MVC
接上次的 spring mvc 注解的一些详细信息！其实也是一些个人的学习笔记呵呵！
替换“\”的时候报错Unexpected internal error near index 1 \ ^ adminjun java “\替换”
发现还是有些东西没有刻子脑子里,,过段时间就没什么概念了,所以贴出来...以免再忘... 在拆分字符串时遇到通过 \ 来拆分，可是用所以想通过转义 \\ 来拆分的时候会报异常 public class Main { /*
POJ 1035 Spell checker(哈希表) aijuans 暴力求解--哈希表
/* 题意：输入字典，然后输入单词，判断字典中是否出现过该单词，或者是否进行删除、添加、替换操作，如果是，则输出对应的字典中的单词要求按照输入时候的排名输出题解：建立两个哈希表。一个存储字典和输入字典中单词的排名，一个进行最后输出的判重 */ #include <iostream> //#define using namespace std; const int HASH =
通过原型实现javascript Array的去重、最大值和最小值 ayaoxinchao JavaScript array prototype
用原型函数（prototype）可以定义一些很方便的自定义函数，实现各种自定义功能。本次主要是实现了Array的去重、获取最大值和最小值。实现代码如下： <script type="text/javascript"> Array.prototype.unique = function() { var a = {}; var le
UIWebView实现https双向认证请求 bewithme UIWebView https Objective-C
什么是HTTPS双向认证我已在先前的博文 ASIHTTPRequest实现https双向认证请求中有讲述，不理解的读者可以先复习一下。本文是用UIWebView来实现对需要客户端证书验证的服务请求，网上有些文章中有涉及到此内容，但都只言片语，没有讲完全，更没有完整的代码，让人困扰不已。但是此知
NoSQL数据库之Redis数据库管理(Redis高级应用之事务处理、持久化操作、pub_sub、虚拟内存) bijian1013 redis 数据库 NoSQL
3.事务处理 Redis对事务的支持目前不比较简单。Redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时，这个连接会进入一个事务上下文，该连接后续的命令不会立即执行，而是先放到一个队列中，当执行exec命令时，redis会顺序的执行队列中
各数据库分页sql备忘 bingyingao oracle sql 分页
ORACLE 下面这个效率很低 SELECT * FROM ( SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_FS_RETURN order by id desc) A ) WHERE RN <20; 下面这个效率很高 SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_
【Scala七】Scala核心一：函数 bit1129 scala
1. 如果函数体只有一行代码，则可以不用写{},比如 def print(x: Int) = println(x) 一行上的多条语句用分号隔开，则只有第一句属于方法体，例如 def printWithValue(x: Int) : String= println(x); "ABC" 上面的代码报错，因为，printWithValue的方法
了解GHC的factorial编译过程 bookjovi haskell
GHC相对其他主流语言的编译器或解释器还是比较复杂的，一部分原因是haskell本身的设计就不易于实现compiler，如lazy特性，static typed，类型推导等。关于GHC的内部实现有篇文章说的挺好，这里，文中在RTS一节中详细说了haskell的concurrent实现，里面提到了green thread，如果熟悉Go语言的话就会发现，ghc的concurrent实现和Go有点类
Java-Collections Framework学习与总结-LinkedHashMap BrokenDreams LinkedHashMap
前面总结了java.util.HashMap，了解了其内部由散列表实现，每个桶内是一个单向链表。那有没有双向链表的实现呢？双向链表的实现会具备什么特性呢？来看一下HashMap的一个子类——java.util.LinkedHashMap。
读《研磨设计模式》-代码笔记-抽象工厂模式-Abstract Factory bylijinnan abstract
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * Abstract Factory Pattern * 抽象工厂模式的目的是： * 通过在抽象工厂里面定义一组产品接口，方便地切换“产品簇” * 这些接口是相关或者相依赖的
压暗面部高光 cherishLC PS
方法一、压暗高光&重新着色当皮肤很油又使用闪光灯时，很容易在面部形成高光区域。下面讲一下我今天处理高光区域的心得：皮肤可以分为纹理和色彩两个属性。其中纹理主要由亮度通道（Lab模式的L通道）决定，色彩则由a、b通道确定。处理思路为在保持高光区域纹理的情况下，对高光区域着色。具体步骤为：降低高光区域的整体的亮度，再进行着色。如果想简化步骤，可以只进行着色（参看下面的步骤1
Java VisualVM监控远程JVM crabdave visualvm
Java VisualVM监控远程JVM JDK1.6开始自带的VisualVM就是不错的监控工具. 这个工具就在JAVA_HOME\bin\目录下的jvisualvm.exe, 双击这个文件就能看到界面通过JMX连接远程机器, 需要经过下面的配置: 1. 修改远程机器JDK配置文件 (我这里远程机器是linux).
Saiku去掉登录模块 daizj saiku 登录 olap BI
1、修改applicationContext-saiku-webapp.xml <security:intercept-url pattern="/rest/**" access="IS_AUTHENTICATED_ANONYMOUSLY" /> <security:intercept-url pattern=&qu
浅析 Flex中的Focus dsjt html Flex Flash
关键字：focus、 setFocus、 IFocusManager、KeyboardEvent 焦点、设置焦点、获得焦点、键盘事件一、无焦点的困扰——组件监听不到键盘事件原因：只有获得焦点的组件（确切说是InteractiveObject）才能监听到键盘事件的目标阶段；键盘事件（flash.events.KeyboardEvent）参与冒泡阶段，所以焦点组件的父项（以及它爸
Yii全局函数使用 dcj3sjt126com yii
由于YII致力于完美的整合第三方库，它并没有定义任何全局函数。yii中的每一个应用都需要全类别和对象范围。例如，Yii::app()->user;Yii::app()->params['name'];等等。我们可以自行设定全局函数，使得代码看起来更加简洁易用。(原文地址) 我们可以保存在globals.php在protected目录下。然后，在入口脚本index.php的，我们包括在
设计模式之单例模式二（解决无序写入的问题） come_for_dream 单例模式 volatile 乱序执行双重检验锁
在上篇文章中我们使用了双重检验锁的方式避免懒汉式单例模式下由于多线程造成的实例被多次创建的问题，但是因为由于JVM为了使得处理器内部的运算单元能充分利用，处理器可能会对输入代码进行乱序执行（Out Of Order Execute）优化，处理器会在计算之后将乱序执行的结果进行重组，保证该
程序员从初级到高级的蜕变 gcq511120594 框架工作 PHP android html5
软件开发是一个奇怪的行业，市场远远供不应求。这是一个已经存在多年的问题，而且随着时间的流逝，愈演愈烈。我们严重缺乏能够满足需求的人才。这个行业相当年轻。大多数软件项目是失败的。几乎所有的项目都会超出预算。我们解决问题的最佳指导方针可以归结为——“用一些通用方法去解决问题，当然这些方法常常不管用，于是，唯一能做的就是不断地尝试，逐个看看是否奏效”。现在我们把淫浸代码时间超过3年的开发人员称为
Reverse Linked List hcx2013 list
Reverse a singly linked list. /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ p
Spring4.1新特性——数据库集成测试 jinnianshilongnian spring 4.1
目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
C# Ajax上传图片同时生成微缩图(附Demo) liyonghui160com
1.Ajax无刷新上传图片,详情请阅我的这篇文章。（jquery + c# ashx） 2.C#位图处理 System.Drawing。 3.最新demo支持IE7,IE8,Fir
Java list三种遍历方法性能比较 pda158 java
从c/c++语言转向java开发，学习java语言list遍历的三种方法，顺便测试各种遍历方法的性能，测试方法为在ArrayList中插入1千万条记录，然后遍历ArrayList，发现了一个奇怪的现象，测试代码例如以下： package com.hisense.tiger.list; import java.util.ArrayList; import java.util.Iterator;
300个涵盖IT各方面的免费资源（上）——商业与市场篇 shoothao seo 商业与市场 IT资源免费资源
A.网站模板+logo+服务器主机+发票生成 HTML5 UP:响应式的HTML5和CSS3网站模板。 Bootswatch:免费的Bootstrap主题。 Templated:收集了845个免费的CSS和HTML5网站模板。 Wordpress.org|Wordpress.com:可免费创建你的新网站。 Strikingly:关注领域中免费无限的移动优
localStorage、sessionStorage uule localStorage
W3School 例子 HTML5 提供了两种在客户端存储数据的新方法： localStorage - 没有时间限制的数据存储 sessionStorage - 针对一个 session 的数据存储之前，这些都是由 cookie 完成的。但是 cookie 不适合大量数据的存储，因为它们由每个对服务器的请求来传递，这使得 cookie 速度很慢而且效率也不

jzyz 题库 题目选做

你可能感兴趣的:(jzyz 题库 题目选做)

jzyz 题库题目选做

你可能感兴趣的:(jzyz 题库题目选做)