第七次报告和标准的练习过程中解决

　　比较大的坡度难度的课题，注册很水的问题，最难的问题是非常困难的；童鞋们也能看到一些问题进行了直接从主要采取OJ的ACM称号，所以，总体来说难度可以说是大多数机器的问题和以前的练习。习的过题数计入平时成绩，能够看作一次超长时长的上机，终于board的情况能够说在意料之中，但也稍微超出了一点预估；希望成绩中没有非常大的水分。

　　A. 邀请函

　　难度中等偏下。

求有向图中一个点出发到全部点再返回的最短路之和。

我们注意到从一个点到全部点就是纯粹的单源最短路；而从全部点返回一个点。倘若我们把图中全部的边反向，就又变成了单源最短路。所以这道题的做法就是对原图和反图各求一遍单源最短路。这里请童鞋们自行区分一下反图和补图的概念。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=1005;
const int INF=0x3f3f3f3f;
int g[MAXN][MAXN],dist[MAXN],n;
bool vis[MAXN];
void dijkstra(int src)
{
    memset(dist,0x3f,sizeof(dist));
    memset(vis,false,sizeof(vis));
    dist[src]=0;
    for(int i=1; i<=n; ++i)
    {
        pair<int,int> tmp=make_pair(INF,-1);
        for(int j=1; j<=n; ++j)
            if(!vis[j]&&dist[j]<tmp.first)
                tmp=make_pair(dist[j],j);
        if(!~tmp.second)
            break;
        vis[tmp.second]=true;
        for(int j=1; j<=n; ++j)
            dist[j]=min(dist[j],tmp.first+g[tmp.second][j]);
    }
}
int main()
{
    int m,u,v,l;
    while(~scanf("%d%d",&n,&m))
    {
        memset(g,0x3f,sizeof(g));
        for(int i=1; i<=n; ++i)
            g[i][i]=0;
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&l);
            g[u][v]=min(g[u][v],l);
        }
        int ans=0;
        dijkstra(1);
        for(int i=1; i<=n; ++i)
            ans+=dist[i];
        for(int i=1; i<=n; ++i)
            for(int j=i+1; j<=n; ++j)
                swap(g[i][j],g[j][i]);
        dijkstra(1);
        for(int i=1; i<=n; ++i)
            ans+=dist[i];
        printf("%d\n",ans);
    }
}
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int MAXN=1005;
const int MAXM=100005;
struct graph
{
    int head[MAXN];
    int to[MAXM];
    int next[MAXM];
    int len[MAXM];
    int tot;
    void init()
    {
        tot=0;
        memset(head,0xff,sizeof(head));
    }
    void add(int u,int v,int w)
    {
        to[tot]=v;
        len[tot]=w;
        next[tot]=head[u];
        head[u]=tot++;
    }
} g,rg;
int dist[MAXN];
bool inque[MAXN];
void spfa(graph &G,int src)
{
    memset(dist,0x3f,sizeof(dist));
    memset(inque,false,sizeof(inque));
    dist[src]=0;
    queue<int> q;
    q.push(src);
    inque[src]=true;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        inque[x]=false;
        for(int i=G.head[x]; ~i; i=G.next[i])
        {
            int y=G.to[i];
            if(dist[x]+G.len[i]<dist[y])
            {
                dist[y]=dist[x]+G.len[i];
                if(!inque[y])
                {
                    q.push(y);
                    inque[y]=true;
                }
            }
        }
    }
}
int main()
{
    int n,m,u,v,l;
    while(~scanf("%d%d",&n,&m))
    {
        g.init();
        rg.init();
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&l);
            g.add(u,v,l);
            rg.add(v,u,l);
        }
        int ans=0;
        spfa(g,1);
        for(int i=1; i<=n; ++i)
            ans+=dist[i];
        spfa(rg,1);
        for(int i=1; i<=n; ++i)
            ans+=dist[i];
        printf("%d\n",ans);
    }
}

　　B. 寻找下界

　　这道题我预谋已久了……题目原打算直接起名叫lower_bound，后来不希望大家使用STL，故而改成不伦不类的中文名；最后干脆直接禁掉了可能利用lower_bound()函数的全部头文件。原因非常easy。二分尽管是每个程序员必须掌握的技巧，但又快又准地写好二分相同是一个学问，找一个序列中的某个数仅仅只是是最基础的操作罢了。

这道题，找的就是大于等于某个数的第一个数，同理，希望大家能自行练习寻找一个序列中大于某个数的第一个数（即upper_bound()函数）。话不多说，扔上三种姿势。

#include<cstdio>
using namespace std;
const int MAXN=100005;
int a[MAXN],n;
int lower_bound(int x)
{
    int l=0,r=n;
    while(l<r)
    {
        int m=l+r>>1;
        x>a[m]?

l=m+1:r=m;
    }
    return l;
}
int main()
{
    int m,k;
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0; i<n; ++i)
            scanf("%d",&a[i]);
        while(m--)
        {
            scanf("%d",&k);
            int idx=lower_bound(k);
            printf("%d\n",idx==n?-1:a[idx]);
        }
    }
}
#include<cstdio>
using namespace std;
const int MAXN=100005;
int a[MAXN],n;
int lower_bound(int x)
{
    int l=0,r=n-1;
    while(l<=r)
    {
        int m=l+r>>1;
        x>a[m]?l=m+1:r=m-1;
    }
    return l;
}
int main()
{
    int m,k;
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0; i<n; ++i)
            scanf("%d",&a[i]);
        while(m--)
        {
            scanf("%d",&k);
            int idx=lower_bound(k);
            printf("%d\n",idx==n?-1:a[idx]);
        }
    }
}
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN=100005;
int a[MAXN];
int main()
{
    int n,m,k;
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0; i<n; ++i)
            scanf("%d",&a[i]);
        while(m--)
        {
            scanf("%d",&k);
            int idx=lower_bound(a,a+n,k)-a;
            printf("%d\n",idx==n?-1:a[idx]);
        }
    }
}

　　C. Cache

　　由于期末上机考试的临近，我们出了这道题，算是对链表操作的回想。这道题其意义在于考查了链表链节的合并和分离操作，倘若能够熟练处理这两个操作，事实上就具备了写块状链表的一切知识和技巧。块状链表不在课程要求内。但有心搞ACM的童鞋最好还是深入探究一下，自行查找资料并手动实现出块状链表的结构和功能。

　　由于有些童鞋说这道题用STL写各种RE，于是我就写了一个能够AC的STL版本号供參考。

#include<iostream>
#include<string>
#include<list>
using namespace std;
list<string> data;
list<string>::iterator cur,tmp;
int main()
{
    int n,m,k;
    while(cin>>n>>m)
    {
        string str,op;
        while(n--)
        {
            cin>>str;
            data.push_back(str);
        }
        cur=data.begin();
        while(m--)
        {
            cin>>op;
            switch(op[4])
            {
            case 'R':
                ++cur;
                if(cur==data.end())
                    --cur;
                break;
            case 'L':
                if(cur!=data.begin())
                    --cur;
                break;
            case 'I':
                tmp=cur;
                ++tmp;
                if(tmp!=data.end())
                {
                    (*cur)+=(*tmp);
                    data.erase(tmp);
                }
                break;
            case 'D':
                cin>>k;
                str=(*cur).substr(k,(*cur).size()-k);
                (*cur)=(*cur).substr(0,k);
                tmp=cur;
                ++tmp;
                data.insert(tmp,str);
                break;
            }
        }
        for(tmp=data.begin(); tmp!=data.end(); ++tmp)
            cout<<(*tmp)<<' ';
        cout<<'\n'<<(*cur)<<'\n';
        data.clear();
    }
}

　　D. 行者无疆

　　从过题数能够看出。这是毫无疑问的最难题。大概一个多月前的一次训练赛，我和Thor合力搞了将近一个小时才做出来。只是当时那道题时限更严苛。后来我们总结了最短路的一些时间复杂度上的经验并写在了这篇blog里。我的做法是如果起点和终点也有充电桩，然后以每一个充电桩为起点跑一遍单源最短路，接着把全部的充电桩放在一起又一次建图，倘若之间的最短路径小于要求则有一条边。然后再从起点跑一遍单源最短路就可以。当然。这道题也能够直接改动dijkstra，理论上速度会更快，但显然从思考难度上又高了一些，这里不再讨论。

　　由于有两次建图且分别求了单源最短路。第一次是稀疏图，第二次是稠密图，所以我多写了一种用spfa处理第一次建图的写法，由于稀疏图下spfa相对于dijkstra的优势还是比較明显的，而稠密图下又会慢于dijkstra。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=305;
const int INF=0x3f3f3f3f;
int city[MAXN][MAXN],pile[MAXN][MAXN],s[MAXN],dist[MAXN];
bool vis[MAXN];
void dijkstra(int g[][MAXN],int n,int src)
{
    memset(dist,0x3f,sizeof(dist));
    memset(vis,false,sizeof(vis));
    dist[src]=0;
    for(int i=1; i<=n; ++i)
    {
        pair<int,int> tmp=make_pair(INF,-1);
        for(int j=1; j<=n; ++j)
            if(!vis[j]&&dist[j]<tmp.first)
                tmp=make_pair(dist[j],j);
        if(!~tmp.second)
            break;
        vis[tmp.second]=true;
        for(int j=1; j<=n; ++j)
            dist[j]=min(dist[j],tmp.first+g[tmp.second][j]);
    }
}
int main()
{
    int n,m,v,k,x,y,d;
    while(~scanf("%d%d%d",&n,&m,&v))
    {
        memset(city,0x3f,sizeof(city));
        for(int i=1; i<=n; ++i)
            city[i][i]=0;
        memset(pile,0x3f,sizeof(pile));
        while(m--)
        {
            scanf("%d%d%d",&x,&y,&d);
            if(d<city[x][y])
                city[x][y]=city[y][x]=d;
        }
        scanf("%d",&k);
        for(int i=1; i<=k; ++i)
            scanf("%d",&s[i]);
        s[++k]=1;
        s[++k]=n;
        for(int i=1; i<=k; ++i)
            pile[i][i]=0;
        for(int i=1; i<=k; ++i)
        {
            dijkstra(city,n,s[i]);
            for(int j=i+1; j<=k; ++j)
            {
                int d=dist[s[j]];
                if(d>v*5)
                    d=INF;
                pile[i][j]=pile[j][i]=d;
            }
        }
        dijkstra(pile,k,k-1);
        printf("%d\n",dist[k]==INF?

-1:dist[k]);
    }
}
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int MAXN=305;
const int MAXM=20005;
const int MAXK=55;
const int INF=0x3f3f3f3f;
struct graph
{
    int head[MAXN];
    int to[MAXM];
    int next[MAXM];
    int len[MAXM];
    int tot;
    void init()
    {
        tot=0;
        memset(head,0xff,sizeof(head));
    }
    void add(int u,int v,int w)
    {
        to[tot]=v;
        len[tot]=w;
        next[tot]=head[u];
        head[u]=tot++;
    }
} city;
int dist[MAXN];
bool inque[MAXN];
void spfa(int src)
{
    memset(dist,0x3f,sizeof(dist));
    memset(inque,false,sizeof(inque));
    dist[src]=0;
    queue<int> q;
    q.push(src);
    inque[src]=true;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        inque[x]=false;
        for(int i=city.head[x]; ~i; i=city.next[i])
        {
            int y=city.to[i];
            if(dist[x]+city.len[i]<dist[y])
            {
                dist[y]=dist[x]+city.len[i];
                if(!inque[y])
                {
                    q.push(y);
                    inque[y]=true;
                }
            }
        }
    }
}
int pile[MAXK][MAXK],s[MAXK],k;
bool vis[MAXK];
void dijkstra(int src)
{
    memset(dist,0x3f,sizeof(dist));
    memset(vis,false,sizeof(vis));
    dist[src]=0;
    for(int i=1; i<=k; ++i)
    {
        pair<int,int> tmp=make_pair(INF,-1);
        for(int j=1; j<=k; ++j)
            if(!vis[j]&&dist[j]<tmp.first)
                tmp=make_pair(dist[j],j);
        if(!~tmp.second)
            break;
        vis[tmp.second]=true;
        for(int j=1; j<=k; ++j)
            dist[j]=min(dist[j],tmp.first+pile[tmp.second][j]);
    }
}
int main()
{
    int n,m,v,x,y,d;
    while(~scanf("%d%d%d",&n,&m,&v))
    {
        city.init();
        while(m--)
        {
            scanf("%d%d%d",&x,&y,&d);
            city.add(x,y,d);
            city.add(y,x,d);
        }
        scanf("%d",&k);
        for(int i=1; i<=k; ++i)
            scanf("%d",&s[i]);
        s[++k]=1;
        s[++k]=n;
        memset(pile,0x3f,sizeof(pile));
        for(int i=1; i<=k; ++i)
            pile[i][i]=0;
        for(int i=1; i<=k; ++i)
        {
            spfa(s[i]);
            for(int j=i+1; j<=k; ++j)
            {
                int d=dist[s[j]];
                if(d>v*5)
                    d=INF;
                pile[i][j]=pile[j][i]=d;
            }
        }
        dijkstra(k-1);
        printf("%d\n",dist[k]==INF?-1:dist[k]);
    }
}

　　E. 多层礼包

　　水题，对栈的复习，不用栈也能做，不再多说。

#include<cstdio>
#include<stack>
using namespace std;
char str[105];
int main()
{
    while(~scanf("%s",&str))
    {
        stack<char> s;
        for(int i=0; str[i]!='G'; ++i)
            switch(str[i])
            {
            case '[':
                s.push(str[i]);
                break;
            case ']':
                if(!s.empty())
                    s.pop();
                break;
            }
        printf("%d\n",s.size());
    }
}
#include<cstdio>
using namespace std;
char str[105];
int main()
{
    while(~scanf("%s",&str))
    {
        int ans=0;
        for(int i=0; str[i]!='G'; ++i)
            switch(str[i])
            {
            case '[':
                ++ans;
                break;
            case ']':
                if(ans>0)
                    --ans;
                break;
            }
        printf("%d\n",ans);
    }
}

　　F. 无线网络

　　这道题的难度在于思路。

题目给出了全部点的坐标。然后非常多人就不知道这是一道什么类型的题了；实质上是给出了一个全然图。然后我们注意到。实现随意寝室的互联，并不须要直接互联。换言之，随意寝室的互联只是寻找一个最小生成树。

然后是怎样处理电力猫的问题，我们注意到电力猫相当于超级版的路由器。实现路由器的功能又不考虑距离，所以如果有k个电力猫，实质上我们是在找最小生成树的第k大边的长度。更具体的讨论能够看POJ原题的

problem_id=2349">Discuss。更具体的证明须要讨论最小生成树和连通分量的关系，能够看这篇文章的第11～12页。此外，这道题是一个全然图。换言之是个非常稠密的图。用prim是比kruskal好得多的选择，尽管我控制了数据量让它们都能过。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int MAXN=505;
const int INF=0x3f3f3f3f;
bool vis[MAXN];
double g[MAXN][MAXN],lowc[MAXN],len[MAXN];
int n,k,x[MAXN],y[MAXN];
inline int sqr(int x)
{
    return x*x;
}
double prim()
{
    memset(vis,false,sizeof(vis));
    for(int i=1; i<=n; ++i)
        lowc[i]=g[1][i];
    vis[1]=true;
    int cnt=0;
    for(int i=1; i<n; ++i)
    {
        int mark=-1;
        double minc=INF;
        for(int j=1; j<=n; ++j)
            if(!vis[j]&&minc>lowc[j])
            {
                minc=lowc[j];
                mark=j;
            }
        if(!~mark)
            return -1;
        len[cnt++]=minc;
        vis[mark]=true;
        for(int j=1; j<=n; ++j)
            if(!vis[j]&&lowc[j]>g[mark][j])
                lowc[j]=g[mark][j];
    }
    sort(len,len+cnt);
    for(int i=0;i<cnt;++i)
        printf("%.2f ",len[i]);
    putchar('\n');
    return len[cnt-k];
}
int main()
{
    while(~scanf("%d%d",&n,&k))
    {
        for(int i=1; i<=n; ++i)
            scanf("%d%d",&x[i],&y[i]);
        for(int i=1; i<=n; ++i)
            for(int j=i; j<=n; ++j)
                g[i][j]=g[j][i]=sqrt(sqr(x[i]-x[j])+sqr(y[i]-y[j]));
        printf("%.2f\n",prim());
    }
}
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int MAXN=505;
const int MAXM=MAXN*MAXN;
inline int sqr(int x)
{
    return x*x;
}
struct edge
{
    int u,v;
    double w;
    edge(int _u=0,int _v=0,double _w=0):u(_u),v(_v),w(_w) {}
    bool operator<(const edge &oth) const
    {
        return w<oth.w;
    }
} e[MAXM];
int n,m,k,x[MAXN],y[MAXN],u[MAXN];
void init()
{
    for(int i=1; i<=n; ++i)
        u[i]=i;
}
int find(int x)
{
    if(u[x]!=x)
        u[x]=find(u[x]);
    return u[x];
}
void merge(int x,int y)
{
    u[find(x)]=find(y);
}
double kruskal()
{
    if(n-k==0)
        return 0;
    sort(e,e+m);
    int cnt=0;
    init();
    for(int i=0; i<m; ++i)
        if(find(e[i].u)!=find(e[i].v))
        {
            merge(e[i].u,e[i].v);
            if(++cnt==n-k)
                return e[i].w;
        }
}
int main()
{
    while(~scanf("%d%d",&n,&k))
    {
        for(int i=1; i<=n; ++i)
            scanf("%d%d",&x[i],&y[i]);
        m=0;
        for(int i=1; i<=n; ++i)
            for(int j=i+1; j<=n; ++j)
            {
                double l=sqrt(sqr(x[i]-x[j])+sqr(y[i]-y[j]));
                e[m++]=edge(i,j,l);
                e[m++]=edge(j,i,l);
            }
        printf("%.2f\n",kruskal());
    }
}

　　G. barty的智商

　　首先说句题外话。barty是北航有史以来第一支也是眼下唯一一支ACM Final队的成员，是GG的队友，专攻图论。这道题也是以前的一道校赛原题，然而它并不难。它突出的思想是怎样把一个求解性问题转化成验证性问题。对于这道题。我们寻找满足要求的最低智商是困难的。但对于某一个智商值，我们推断它是否满足要求是easy的，仅仅要跑一遍拓扑排序就能够了。于是能够产生二分答案的思想，就是在智商值的范围内进行二分，对于每个值进行验证；二分过程和B题极其相似，也是在找一个下界（从而也能够看出对于二分，像书上单纯的查找某个值是否存在是最基础的，而B题的二分方式相同是有意义的）。

　　验证的时候能够选择建立新图，这里使用了vector模拟邻接表。

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int MAXN=10005;
const int INF=0x3f3f3f3f;
vector<pair<int,int> > G[MAXN];
vector<int> g[MAXN];
int du[MAXN],n;
bool toposort()
{
    memset(du,0,sizeof(du));
    for(int i=1; i<=n; ++i)
        for(int j=0; j<g[i].size(); ++j)
            ++du[g[i][j]];
    int tot=0;
    queue<int> q;
    for(int i=1; i<=n; ++i)
        if(!du[i])
            q.push(i);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        ++tot;
        for(int i=0; i<g[u].size(); ++i)
        {
            int v=g[u][i];
            if(!(--du[v]))
                q.push(v);
        }
    }
    return tot==n;
}
int main()
{
    int t,m,a,b,c;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=1; i<=n; ++i)
            G[i].clear();
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&c);
            G[b].push_back(make_pair(a,c));
        }
        int l=0,r=INF;
        while(l<r)
        {
            int m=l+r>>1;
            for(int i=1; i<=n; ++i)
            {
                g[i].clear();
                for(int j=0; j<G[i].size(); ++j)
                    if(G[i][j].second>m)
                        g[i].push_back(G[i][j].first);
            }
            toposort()?r=m:l=m+1;
        }
        printf("%d\n",l);
    }
}

　　也能够不建新图。对拓扑排序稍作修改。用前向星来写的邻接表。

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int MAXN=10005;
const int MAXM=10005;
const int INF=0x3f3f3f3f;
struct graph
{
    int head[MAXN];
    int to[MAXM];
    int next[MAXM];
    int len[MAXM];
    int tot;
    void init()
    {
        tot=0;
        memset(head,0xff,sizeof(head));
    }
    void add(int u,int v,int w=-1)
    {
        to[tot]=v;
        len[tot]=w;
        next[tot]=head[u];
        head[u]=tot++;
    }
} g;
int du[MAXN],n;
bool toposort(int k)
{
    memset(du,0,sizeof(du));
    for(int i=1; i<=n; ++i)
        for(int j=g.head[i]; ~j; j=g.next[j])
            if(g.len[j]>k)
                ++du[g.to[j]];
    int tot=0;
    queue<int> q;
    for(int i=1; i<=n; ++i)
        if(!du[i])
            q.push(i);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        ++tot;
        for(int i=g.head[u]; ~i; i=g.next[i])
            if(g.len[i]>k)
            {
                int v=g.to[i];
                if(!(--du[v]))
                    q.push(v);
            }
    }
    return tot==n;
}
int main()
{
    int t,m,a,b,c;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        g.init();
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&c);
            g.add(a,b,c);
        }
        int l=0,r=INF;
        while(l<r)
        {
            int m=l+r>>1;
            toposort(m)?r=m:l=m+1;
        }
        printf("%d\n",l);
    }
}

　　总的来说，我想给全部坚持独立完毕题目的童鞋点个赞。这次的题目可做性非常强，但也确实非常有难度，坚持做下来的人非常值得鼓舞。期末考试临近，希望大家好好复习重点的数据结构和算法，期末上机和笔试加油～（尽管上机是我们出题，写我们的外表似参加平地机or合分……）

版权声明：本文博客原创文章，博客，未经同意，不得转载。

时间： 2024-11-06 12:36:59

第七次报告和标准的练习过程中解决的相关文章

关于在七牛使用过程中视频播放器的推荐方案

Qiniu 七牛问题解答 很多七牛用户在使用七牛云存储过程中遇到视频播放器选择的问题,这里我做下简单的推荐. 音视频支持 音视频播放 在依托七牛云存储建立视频应用的过程中,使用者时常遇到播放的问题:选择什么样的播放器?使用什么样的编码和容器格式?如何适应多种客户端?等等. 播放器的要求 视频应用通常要求播放器具备以下的基本特性: 多客户端支持.包括:PC端(Web播放)和移动端(iOS,Android等).具备多平台支持的播放器有助于简化开发,规避平台之间的差异. 常用的音视频编码格式支持.常用

标准动作中犯的错误，使用过程中忘记写结束符号所发生的错误

例如 错误写法: <jsp:getProperty property="userName" name="user" > 正确写法:<jsp:getProperty property="userName" name="user" /> 导致的异常: HTTP Status 500 - type Exception report message description The server encounte

使用Visual Studio在标准Web Part 部件中创建事件处理器

使用Visual Studio在标准Web Part 部件中创建Event Handler 为Web Part部件创建Events是生成Web Parts部件的核心部分.本文主要讲解如何使用Visual Studio在标准Web Part 部件中创建事件处理器. 1. 打开Visual Studio 创建新的空白SharePoint项目SPWebPartEvent,点击确定.部署为场解决方案. 2. 右击项目添加新Web部件SampleEventWebPart.点击确定. 3. 打开Sample

关于在linux下出现stdio.h文件不存在等gcc标准库不能找到的解决办法

首先说明一下我的系统配置:ubuntu 12.04     gcc 4.6.3 有几天没有使用ubuntu了,今天拿出来编程序,刚开始编译一个uboot1.1.6的代码.出现了stdio.h:没有那么个文件或目录的错误,因为我是用的arm-linux-gcc交叉编译编的,所以我刚开始怀疑是不是我的编译器有问题.后来我去编译以前写的一个网络程序 用gcc -o test test.c  然后还是出现了stdio.h:没有那么个文件或目录的错误.然后就各种google,百度.最后的解决方案是: 我的

C++的标准模板库STL中实现的数据结构之顺序表vector的分析与使用

摘要 本文主要借助对C++的标准模板库STL中实现的数据结构的学习和使用来加深对数据结构的理解.即联系数据结构的理论分析和详细的应用实现(STL),本文是系列总结的第一篇,主要针对线性表中的顺序表(动态数组)STL vector进行分析和总结. 引言 因为前段时间对台大的机器学习基石和技法课程进行了学习,发如今详细的实现中经常涉及到各种类型的数据结构,比方线性表.二叉树.图等,在使用这些数据结构时感到有些吃力.主要是对一些主要的数据结构理解的不够.所以趁着暑假假期.近期一段时间总会抽出时间复习一

浏览器加载和渲染HTML的过程（标准定义的过程以及现代浏览器的优化）

先看一下标准定义的浏览器渲染过程(网上找的): 浏览器打开网页的过程 用户第一次访问网址,浏览器向服务器发出请求,服务器返回html文件: 浏览器开始载入html代码,发现 head 标签内有一个 link 标签引用外部CSS或JS文件: 浏览器又发出CSS及JS文件的请求,服务器返回这个CSS,JS文件: 浏览器继续载入html中 body 部分的代码,并且CSS,JS文件已经拿到手了,可以开始渲染页面了: 浏览器在代码中发现一个 img 标签引用了一张图片,向服务器发出请求.此时浏览器不会等

std中vector的实现原理（标准模板动态库中矢量的实现原理）

我们实现的数据结构是为了解决在运行过程中动态的开辟空间使用(例如我们不停的输入,输入的多少我们不确定) 原理两种: 一.笨办法 我们第一次用多少空间,开辟多少空间A 我们第二次用空间,会开辟大于第一次开辟的空间B,将A里的数据拷贝到B中,然后释放A,在C中写入新的数据 缺点:在于拷贝的次数太多,效率低 二.改进的办法 矢量有一个参数,里面填写预留的空间,加入我们填写的预留空间大小是B,这里是预留,并没有真正的开辟物理内存,预留的作用于如果这时候如果需要开辟空间做其他事情,开辟的空间会避开B,这样

大型项目使用Automake/Autoconf完成编译配置（标准的编译过程已经变成了简单的三部曲：configure/make/make install,）

使用过开源C/C++项目的同学们都知道,标准的编译过程已经变成了简单的三部曲:configure/make/make install, 使用起来很方便,不像平时自己写代码,要手写一堆复杂的Makefile,而且换个编译环境,Makefile还需要修改(Eclipse也是这样). 这么好的东东当然要拿来用了,但GNU的Autotool系列博大精深,工具数量又多,涉及的语言也多,要是自己从头看到尾,黄花菜都凉了,项目估计早就结束了:上网搜样例倒是有一大堆,但都是“hello world”的样例,离真

生动形象讲解 OSI 七层模型和两主机传输过程?

我们假设每个个体就是一台电脑,我们生活中的物品就是电脑中保存的文件.我们有一天想要与世界上其他地方的人交换货物,我们会用什么方法呢? 我们首先会看我们想要交换什么样的物品,如果是电子产品,可能会上苏宁易购,如果是书本,可能会上当当网,如果是服装裤子,可能会上淘宝或京东,如果是生活中的小玩意,可能会上咸鱼.这些电商平台为我们交换货物提供了专用的通道和规则,我们称这些平台为应用层.(应用层作用:为网络用户之间的通信提供专用的程序和协议) 提供不同服务的电商平台 假设我们最终选择在淘宝上卖给别人一个衣