POJ 3984

【类型】

bfs

【Tip】

当结构体内部有构造函数时,不能定义二维结构体.

【Code】

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<stack>
using namespace std;
struct node{
    int x,y,sx,sy;
    //node(int xx,int yy,int ssx,int ssy):x(xx),y(yy),sx(ssx),sy(ssy) {}
};
node position[10][10];
queue q;
int vi[6][6]={0};
int maze[5][5]={
    0, 1, 0, 0, 0,
    0, 1, 0, 1, 0,
    0, 0, 0, 0, 0,
    0, 1, 1, 1, 0,
    0, 0, 0, 1, 0,
};

void Bac(int x,int y){
    if(x==-1,y==-1){
        return;
    }
    Bac(position[x][y].x,position[x][y].y);
    printf("(%d, %d)\n",x,y);
}

node Anode(int x,int y,int sx,int sy){
    node A;
    A.x=x;
    A.y=y;
    A.sx=sx;
    A.sy=sy;
    return A;
}

void bfs(){
    position[0][0].x=-1;
    position[0][0].y=-1;
    position[0][0].sx=0;
    position[0][0].sy=0;
    q.push(Anode(-1,-1,0,0));
    vi[0][0]=1;
    while(!q.empty()){
        node a=q.front();
        if(a.sx==4 && a.sy==4){
            Bac(a.sx,a.sy);
            return;
        }
        q.pop();
        if(a.sx+1=0 && !vi[a.sx][a.sy-1]&& !maze[a.sx][a.sy-1]){
            position[a.sx][a.sy-1].sx=a.sx;
            position[a.sx][a.sy-1].sy=a.sy-1;
            position[a.sx][a.sy-1].x=a.sx;
            position[a.sx][a.sy-1].y=a.sy;
            q.push(Anode(a.sx,a.sy,a.sx,a.sy-1));
            vi[a.sx][a.sy-1]=1;
        }
        if(a.sx-1>=0 && !vi[a.sx-1][a.sy]&& !maze[a.sx-1][a.sy]){
            position[a.sx-1][a.sy].sx=a.sx-1;
            position[a.sx-1][a.sy].sy=a.sy;
            position[a.sx-1][a.sy].x=a.sx;
            position[a.sx-1][a.sy].y=a.sy;
            q.push(Anode(a.sx,a.sy,a.sx-1,a.sy));
            vi[a.sx-1][a.sy]=1;
        }
    }
}
int main(){
    bfs();
    return 0;
}

算法学习-图论相关一些基础

【先贴上大神的代码截图】

 

floyd&spfa

 

【Code】

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
struct node{
    node *next;
    int where;
    int cost;
}a[10001],*first[1001];

bool b[1001];

inline void dfs(int now){
    b[now]=true;
    for(node *x=first[now];x;x=x->next)
        if(!b[x->where])
            dfs(x->where);
}

inline void bfs(int S){
    int c[1001];
    c[1]=S;
    for(int k=1,l=1,l<=k;++l){
        int m=c[1];
        for(node *x=first[m];x;x=x->next)
            if(!b[x->where])
                b[x->where]=true,
                c[++k]=x->where;    
    }
}
//floyd只是一个模板
inline void floyd(){
    for(int k=1;k<=n;++k)
        for(int i=1;i<=n;++i)
            for(int j=1;j<=n;++j)
                f[i][j]=min(f[i][j],f[i][k]+f[k][j]);
}

//可以处理负边
inline void spfa(int S,int T){
    int c[1001],dist[1001];
    c[1]=S;
    memset(dist,127,sizeof(dist));
    dist[S]=0;
    for(int k=1,l=1;l<=k;++l){
        int m=c[1];
        b[m]=false;
        for(node *x=first[m];x;x=x->next)
            if(dist[m]+x->cost<dist[x->where])
            {
                dist[x->where]=dist[m]+x->cost;
                if(!b[x->where])
                    b[x->where]=true,
                    c[++k]=x->where;
            }
    }
        
    
}
int main(){
    return 0;
}

Android 学习 碎片的生命周期

【reference】

《第一行代码-第二版》 GuoLin

【Prior knowledge/先备知识】

BaiDu or Google it…= =

 

【碎片的状态和回调】

1.每个活动在其生命周期内可能会有四种状态.

-运行状态

-暂停状态

-停止状态

-销毁状态

类似的,碎片也可能会经历这几种状态,不过会有一些细小的地方的部分区别.

2.运行状态

当一个碎片是可见的,并且他所关联的活动正处于运行状态时,该碎片也处于运行状态.

3.暂停状态

当一个活动进入暂停状态时(由于另一个未占满屏幕的活动被添加到了栈顶),与他相关联的可见碎片就会进入到暂停状态.

4.停止状态

当一个活动进入停止状态时,与他相关联的碎片就会进入到停止状态,或者通过调用FragmentTrasaction的remove(),replace()方法把碎片从活动移除,但如果在事务提交之前调用addToBackStack()方法,这时的碎片也会进入到停止状态。总的来说,进入停止状态的碎片对用户来说是完全不可见的,有可能会被系统回收.

5.销毁状态

碎片总是依附于活动而存在的,因此当活动被销毁时,与他相关联的碎片也就会进入到销毁态.

或者通过调用FragmentTransaction 的remove()、replace()方法将碎片从活动中移除,

在事务提交之前并没有调用addToBackStack()方法,这时的碎片也会进入到销毁状态。

 

Fragment提供的附加回调方法:

①onAttach()
当碎片和活动建立关联的时候调用。


②onCreateView()
为碎片创建视图(加载布局)时调用。


③ onActivityCreated()
确保与碎片相关联的活动一定已经创建完毕的时候调用。


④onDestroyView()
当与碎片关联的视图被移除的时候调用。

⑤onDetach()
当碎片和活动解除关联的时候调用。

 

【碎片的完整生命周期】

 

 

附上github源码(这一篇的project是FragmentTest):  clone这个项目

 

算法学习-线段树

【概念】

线段树是擅长处理区间的,且是一颗完美二叉树(Perfect Binary Tree),树上每一个节点都维护一个区间,根维护的是整个区间,每个节点维护的是父亲的区间二等分后的其中一个子区间。当有n个元素时,对区间的操作可以在O(log n)的时间内完成.

以下我们以实现了Range Minimum Query(RMQ,范围最小值查询)操作的线段树为例,进行说明.

【基于线段树的RMQ的结构】

Continue reading “算法学习-线段树”

Android 学习 抽象类

【Tip】

抽象类只是一个面向对象的概念,所以可以用在诸如.net,jave EE,PY…..

【在Android中概念】

   抽象类

我们都知道在面向对象的领域一切都是对象,同时所有的对象都是通过类来描述的,但是并不是所有的类都是来描述对象的。如果一个类没有足够的信息来描述一个具体的对象,而需要其他具体的类来支撑它,那么这样的类我们称它为抽象类。比如new Animal(),我们都知道这个是产生一个动物Animal对象,但是这个Animal具体长成什么样子我们并不知道,它没有一个具体动物的概念,所以他就是一个抽象类,需要一个具体的动物,如狗、猫来对它进行特定的描述,我们才知道它长成啥样。

Continue reading “Android 学习 抽象类”

OpenJudge 程序设计与算法(二)第五周作业(2017春季)

–动态规划

【1:拦截导弹】

【Code】

#include<bits/stdc++.h>
using namespace std;
const int maxn=70;
int a[maxn],N;
int maxlen[maxn],m=-1;
int main(){
    cin>>N;
    for(int i=1;i<=N;++i){
        cin>>a[i]; maxlen[i]=1;
    }
    for(int i=2;i<=N;++i)
        for(int j=1;j<i;++j)
            if(a[i]<=a[j]){
                maxlen[i]=max(maxlen[i],maxlen[j]+1);
                if(maxlen[i]>m) m=maxlen[i];
            }
    cout<<m<<endl;
    return 0;
}

最长上升序列问题,目前对动规的理解走到了明白1.动规是逆着的递归.2.动规是通过从尾开始动态的更改所有的最忧解,从而找到所需要的最优解.