几百年前的东西

最新推荐文章于 2024-04-06 22:38:59 发布
最新推荐文章于 2024-04-06 22:38:59 发布
阅读量302 收藏
点赞数
分类专栏： C/C++ Algorithms
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fancy_Real/article/details/62441638
版权

最近一个月左右整理的东西，基本上都是关于图论的。
最短距离
最小生成树
连通性
网络流
以及还有下面关于最短路的题目。
一些题目是来自与Vjudge上的，以下也给出了题目的链接。

/*
 *http://poj.org/problem?id=2387
 *Memory 4692
 *Time 79
*/
#include <iostream>
using namespace std;
const int MAXN = 1002;
const int INF = (1 << 30);
int Map[MAXN][MAXN];
int dis[MAXN];
bool vis[MAXN];
int Dijsktral(int s, int t, int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int T, N;
    int A, B, L;
    while(cin>>T>>N) {
        for(int i = 0; i <= N; ++i) {
            for(int j = 0; j <= N; ++j) {
                Map[i][j] = INF;
            }
        }
        for(int i = 0; i < T; ++i) {
            cin>>A>>B>>L;
            Map[A][B] = Map[A][B] < L? Map[A][B]: L;
            Map[B][A]= Map[A][B];
        }
        cout<<Dijsktral(N, 1, N)<<endl;
    }
    return 0;
}
int Dijsktral(int s, int t, int n)
{
    for(int i = 1; i <= n; ++i) {
        dis[i] = Map[s][i];
        vis[i] = false;
    }
    vis[s] = true, dis[s] = 0;
    for(int i = 1; i < n; ++i) {
        int Min = INF, index = s;
        for(int j = 1; j <= n; ++j) {
            if(!vis[j] && Min > dis[j]) Min = dis[j], index = j;
        }
        if(Min == INF) break;
        vis[index] = true;
        for(int j = 1; j <= n; ++j) {
            if(!vis[j] && dis[j] > dis[index] + Map[index][j]) {
                dis[j] = dis[index] + Map[index][j];
            }
        }
    }
    return dis[t];
}
/*
 *http://poj.org/problem?id=2253
 *Memory 596
 *Time 16
*/
#include <iostream>
#include <stdio.h>
#include <vector>
#include <math.h>
using namespace std;
const int MAXN = 201;
const int INF = (1<<30);
double Map[MAXN][MAXN];
double dis[MAXN];
bool vis[MAXN];
struct Stone{
    int x, y;
}s;
vector<struct Stone> stoneOfV;
double TDijkstra(int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, scenario = 1;
    while(cin>>n && n) {
        for(int i = 0; i < n; ++i) {
            cin>>s.x>>s.y;
            stoneOfV.push_back(s);
        }
        cout<<"Scenario #"<< scenario <<endl;
        printf("Frog Distance = %.3lf\n", TDijkstra(n));
        cout<<endl;
        scenario++;
        stoneOfV.clear();
    }
    return 0;
}
double TDijkstra(int n)
{
    int Size = stoneOfV.size();
    for(int i = 0; i < Size; ++i) {
        for(int j = 0; j < Size; ++j) {
            double x = stoneOfV[i].x - stoneOfV[j].x;
            double y = stoneOfV[i].y - stoneOfV[j].y;
            Map[i][j] = Map[j][i] = sqrt(x * x + y * y);
        }
    }
    for(int i = 0; i < Size; ++i) dis[i] = Map[0][i], vis[i] = false;
    dis[0] = 0, vis[0] = true;
    for(int i = 1; i < Size; ++i) {
        int index = 0;
        double Min = INF;
        for(int j = 0; j < Size; ++j)
            if(!vis[j] && Min > dis[j]) Min = dis[j], index = j;
        if(index == 0) break;
        vis[index] = true;
        for(int j = 0; j < Size; ++j) {
            if(!vis[j] && dis[index] >= Map[index][j]) {
                if(dis[index] < dis[j]) dis[j] = dis[index];
            } else if(!vis[j] && dis[index] < Map[index][j]) {
                if(Map[index][j] < dis[j]) dis[j] = Map[index][j];
            }
        }
    }
    return dis[1];
}
/*
 *http://poj.org/problem?id=3268
 *Memory 4692
 *Time 94
*/
#include <iostream>
#include <algorithm>
using namespace std;
const int MAXN = 1002;
const int INF = (1<<30);
int Map[MAXN][MAXN];
int disX[MAXN], dis[MAXN];
bool vis[MAXN];
void dijkstra(int x, int n, int *dis);
void Transform(int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    int n, m, x;
    int A, B;
    while(cin>>n>>m>>x) {
        for(int i = 0; i <= n; ++i)
            for(int j = 0; j <= n; ++j)
                Map[i][j] = INF;
        for(int i = 0; i < m; ++i) {
            cin>>A>>B;
            cin>>Map[A][B];
        }
        dijkstra(x, n, disX);
        Transform(n);
        dijkstra(x, n, dis);
        int Max = 0;
        for(int i = 1;i <= n; ++i) {
            disX[i] += dis[i];
            if(i != x) Max = Max > disX[i]? Max: disX[i];
        }
        cout<<Max<<endl;
    }
    return 0;
}
void dijkstra(int x, int n, int *dis)
{
    for(int i = 1; i <= n; ++i)
        dis[i] = Map[x][i], vis[i] = false;
    dis[x] = 0, vis[x] = true;
    for(int i = 1; i < n; ++i) {
        int Min = INF, index = x;
        for(int j = 1; j <= n; ++j) {
            if(!vis[j] && Min > dis[j]) Min = dis[j], index = j;
        }
        vis[index] = true;
        for(int j = 1; j <= n; ++j) {
            if(!vis[j] && dis[j] > dis[index] + Map[index][j])
                dis[j] = dis[index] + Map[index][j];
        }
    }
}
void Transform(int n)
{
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j < i; ++j)
            swap(Map[i][j], Map[j][i]);
}
/*
 *http://poj.org/problem?id=1860
 *Memory 872
 *Time 110
*/
#include <iostream>
using namespace std;
const int MAXN = 102;
double MapR[MAXN][MAXN];
double MapC[MAXN][MAXN];
double dis[MAXN];
bool vis[MAXN];
void Init(int n);
void dijkstra(int s, int n, double v);
bool Floyd(int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, m, s;
    double v;
    int a, b;
    while(cin>>n>>m>>s>>v) {
        Init(n);
        for(int i = 0; i < m; ++i) {
            cin>>a>>b;
            cin>>MapR[a][b]>>MapC[a][b];
            cin>>MapR[b][a]>>MapC[b][a];
        }
        dijkstra(s, n, v);
        if(Floyd(n)) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    return 0;
}
void Init(int n)
{
    for(int i = 0; i <= n; ++i)
        for(int j = 0; j <= n; ++j)
            dis[i] = MapR[i][j] = MapC[i][j] = 0;
}
void dijkstra(int s, int n, double v)
{
    for(int i = 0; i <= n; ++i)
        dis[i] = (v - MapC[s][i]) * MapR[s][i], vis[i] = false;
    dis[s] = v, vis[s] = true;
    for(int i = 1; i < n; ++i) {
        double Max = 0;
        int index = s;
        for(int j = 1; j <= n; ++j) {
            if(!vis[j] && Max < dis[j]) Max = dis[j], index = j;    
        }
        vis[index] = true;
        for(int j = 1; j <= n; ++j) {
            double vk = (dis[index] - MapC[index][j]) * MapR[index][j];
            if(!vis[j] && dis[j] < vk) dis[j] = vk;
        }
    }
}
bool Floyd(int n)
{
    int k;
    bool flag = true;
    for(k = 1; flag && k <= n; ++k) {
        flag = false;
        for(int i = 1; i <= n; ++i)
            for(int j = 1; j <= n; ++j) {
                double v = (dis[i] - MapC[i][j]) * MapR[i][j];
                if(v > dis[j]) dis[j] = v,  flag = true;    
            }
    }
    return k > n;
}
/*
 *http://poj.org/problem?id=3660
 *Memory 688
 *Time 79
*/
#include <iostream>
using namespace std;
const int MAXN = 102;
bool Map[MAXN][MAXN];
void Floyd(int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    int a, b;
    while(cin>>n>>m) {
        for(int i = 0; i <= n; ++i)
            for(int j = 0; j <= n; ++j)
                Map[i][j] = false;
        for(int i = 0; i < m; ++i) {
            cin>>a>>b;
            Map[a][b] = true;
        }
        Floyd(n);
    }
    return 0;
}
void Floyd(int n)
{
    for(int k = 1; k <= n; ++k)
        for(int i = 1; i <= n; ++i)
            for(int j = 1; j <= n; ++j)
                if(Map[i][k] && Map[k][j]) Map[i][j] = true;
    int ans = 0;
    for(int j, i = 1; i <= n; ++i) {
        for(j = 1; j <= n; ++j) {
            if(i == j) continue;
            if(!Map[i][j] && !Map[j][i]) break;
        }
        if(j > n) ans++;
    }
    cout<<ans<<endl;
}
/*
 *http://poj.org/problem?id=1062
 *Memory 264kb
 *Time 32ms
*/
#include <iostream>
using namespace std;
const int MAXN = 102;
const int INF = (1<<30);
int Map[MAXN][MAXN];
int Lev[MAXN];
int dis[MAXN];
bool vis[MAXN];
void Init(int n);
int Dijkstra(int s, int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int m, n;
    int v, l, k, x;
    while(cin>>m>>n) {
        Init(n);
        for(int i = 1; i <= n; ++i) {
            cin>>v>>l>>k;
            Map[0][i] = v, Lev[i] = l;
            for(int j = 0; j < k ; ++j) {
                cin>>x>>v;
                Map[x][i] = v;
            }
        }
        int ans = INF;
        for(int i = 1; i <= n; ++i) {
            int Min = Lev[i];
            for(int j = 1; j <= n; ++j) {
                if(Min > Lev[j] || Lev[j] - Min > m) vis[j] = true;
                else vis[j] = false;
            }
            int tmp = Dijkstra(0, n);
            ans = ans < tmp? ans: tmp;
        }
        cout<<ans<<endl;
    }
    return 0;
}
void Init(int n)
{
    for(int i = 0; i <= n; ++i)
        for(int j = 0; j <= n; ++j)
            Map[i][j] = Map[j][i] = INF;
}
int Dijkstra(int s, int n)
{
    for(int i = 0; i <= n; ++i)
        dis[i] = Map[s][i];
    for(int i = 1; i < n; ++i) {
        int Min = INF, index = s;
        for(int j = 1; j <= n; ++j) {
            if(!vis[j] && Min > dis[j]) Min = dis[j], index = j;
        }
        vis[index] = true;
        for(int j = 1; j <= n; ++j) {
            if(!vis[j] && dis[j] > dis[index] + Map[index][j])
                dis[j] = dis[index] + Map[index][j];
        }
    }
    return dis[1];
}
/*
 *http://poj.org/problem?id=3169
*/
/*version one
 *Memory 412
 *Time 188
*/
#include <iostream>
using namespace std;
const int MAXE = 20004;
const int MAXN = 10002;
const int INF = (1<<30);
int head[MAXN];
bool vis[MAXN];
int cnt[MAXN];
int que[MAXN];
int dist[MAXN];

struct Edge{
    int to, v, next;
}edge[MAXE];
int tol;
void add(int a, int b, int v);
bool SPFA(int s, int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, ML, MD;
    int a, b, c;
    while(cin>>n>>ML>>MD) {
        tol = 0;
        for(int i = 0; i < MAXN; ++i) head[i] = -1;
        for(int i = 0; i < ML; ++i) {
            cin>>a>>b>>c;
            if(a > b) swap(a, b);
            add(a, b, c);
        }
        for(int i = 0; i < MD; ++i) {
            cin>>a>>b>>c;
            if(a < b) swap(a, b);
            add(a, b, -c);
        }
        if(!SPFA(1, n)) cout<<"-1"<<endl;
        else if(dist[n] == INF) cout<<"-2"<<endl;
        else cout<<dist[n]<<endl;
    }
    return 0;
}
void add(int a, int b, int v)
{
    edge[tol].to = b;
    edge[tol].v = v;
    edge[tol].next = head[a];
    head[a] = tol++;
}
bool SPFA(int s, int n)
{
    int front = 0, rear = 0;
    for(int v = 1; v <= n; ++v) {
        if(v == s) {
            que[rear++] = v;
            vis[v] = true;
            cnt[v] = 1;
            dist[v] = 0;
        }else {
            vis[v] = false;
            cnt[v] = 0;
            dist[v] = INF;
        }
    }
    while(front != rear) {
        int u = que[front++];
        vis[u] = false;
        if(front >= MAXN) front = 0;
        for(int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if(dist[v] > dist[u] + edge[i].v) {
                dist[v] = dist[u] + edge[i].v;
                if(!vis[v]) {
                    vis[v] = true;
                    que[rear++] = v;
                    if(rear >= MAXN) rear = 0;
                    if(++cnt[v] > n) return false;
                }
            }
        }
    }
    return true;
}
/*version two
 *Memory 352
 *Time 157
*/
#include <iostream>
using namespace std;
const int MAXN = 10002;
const int MAXE = 20004;
const int INF = (1<<30);
int dist[MAXN];
int edge[MAXE][3];
int tol;
bool bellman(int s, int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, ML, MD;
    int a, b, c;
    while(cin>>n>>ML>>MD) {
        tol = 0;
        for(int i = 0; i < ML; ++i) {
            cin>>a>>b>>c;
            if(a > b) swap(a, b);
            edge[tol][0] = a;
            edge[tol][1] = b;
            edge[tol][2] = c;
            tol++;
        }
        for(int i = 0; i < MD; ++i) {
            cin>>a>>b>>c;
            if(a < b) swap(a, b);
            edge[tol][0] = a;
            edge[tol][1] = b;
            edge[tol][2] = -c;
            tol++;
        }
        if(!bellman(1, n)) cout<<"-1"<<endl;
        else if(dist[n] == INF) cout<<"-2"<<endl;
        else cout<<dist[n]<<endl;
    }
    return 0;
}
bool bellman(int s, int n)
{
    for(int i = 1; i <= n; ++i) dist[i] = INF;
    dist[s] = 0;
    for(int i = 1; i < n; ++i) {
        bool flag = false;
        for(int j = 0; j < tol; ++j) {
            int u = edge[j][0], v = edge[j][1];
            if(dist[v] > dist[u] + edge[j][2])
                dist[v] = dist[u] + edge[j][2], flag = true;
        }
        if(!flag) break;
    }
    for(int i = 0; i < tol; ++i)
        if(dist[edge[i][1]] > dist[edge[i][0]] + edge[i][2])
            return false;
    return true;
}
/*
 *http://poj.org/problem?id=3159
 *Memory 2428
 *Time 547
*/
#include <iostream>
#include <stdio.h>
using namespace std;
const int MAXN = 30003;
const int MAXE = 150009;
const int INF = (1<<30);
int head[MAXN];
bool vis[MAXN];
int sta[MAXN];
int dist[MAXN];
struct Edge{
    int to, v, next;
}edge[MAXE];
int tol;
void add(int a, int b, int v);
void SPFA(int s, int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    int a, b, c;
    while(~scanf("%d%d", &n, &m)) {
        tol = 0;
        for(int i = 0; i < MAXN; ++i) head[i] = -1;
        for(int i = 0; i < m; ++i) {
            scanf("%d%d%d", &a, &b, &c);
            //b-a<=c
            add(a, b, c);
            //big - small <= c, samll->big : c
        }
        SPFA(1, n);
        printf("%d\n", dist[n]);
    }
    return 0;
}
void add(int a, int b, int v)
{
    edge[tol].to = b;
    edge[tol].v = v;
    edge[tol].next = head[a];
    head[a] = tol++;
}
void SPFA(int s, int n)
{
    int top = 0;
    for(int v = 1; v <= n; ++v) {
        if(v == s) {
            sta[top++] = v;
            vis[v] = true;
            dist[v] = 0;
        } else {
            vis[v] = false;
            dist[v] = INF;
        }
    }
    while(top != 0) {
        int u = sta[--top];
        vis[u] = false;
        for(int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if(dist[v] > dist[u] + edge[i].v) {
                dist[v] = dist[u] + edge[i].v;
                if(!vis[v]) {
                    vis[v] = true;
                    sta[top++] = v;
                }
            }
        }
    }
}
/*
 *http://acm.hdu.edu.cn/showproblem.php?pid=4370
 *Memory 1968
 *Time 592
*/
#include <iostream>
using namespace std;
const int MAXN = 303;
const int INF = (1<<30);
int C[MAXN][MAXN];
int dist[MAXN];
int que[MAXN];
bool vis[MAXN];
void SPFA(int s, int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n;
    while(cin>>n) {
        for(int i = 1; i <= n; ++i)
            for(int j = 1; j <= n; ++j)
                cin>>C[i][j];
        SPFA(1, n);
        int ans = dist[n];
        int loopOfOne = dist[1];
        SPFA(n, n);
        int loop = dist[n] + loopOfOne;
        ans = ans < loop? ans: loop;
        cout<<ans<<endl;
    }
    return 0;
}
void SPFA(int s, int n)
{
    int front = 0, rear = 0;
    for(int v = 1; v <= n; ++v) {
        if(v == s) {
            dist[v] = INF;
            vis[v] = false;
        } else if(C[s][v] != INF) {
            dist[v] = C[s][v];
            que[rear++] = v;
            vis[v] = true;
        } else {
            dist[v] = INF;
            vis[v]= false;
        }
    }
    while(front != rear) {
        int u = que[front++];
        for(int v = 1; v <= n; ++v) {
            if(dist[v] > dist[u] + C[u][v]) {
                dist[v] = dist[u] + C[u][v];
                if(!vis[v]) {
                    vis[v] = true;
                    que[rear++] = v;
                    if(rear >= MAXN) rear = 0;
                }
            }
        }
        vis[u] = false;
        if(front >= MAXN) front = 0;
    }
}
/*
 *http://acm.hdu.edu.cn/showproblem.php?pid=4725
*/
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int MAXN = 100002;
const int INF = 1<<30;
struct qNode{
    int v, c;
    qNode(int _v = 0, int _c = 0):v(_v), c(_c){
    }
    bool operator < (const qNode &r) const{
        return c > r.c;
    }
};
struct Edge{
    int v, cost;
    Edge(int _v = 0, int _cost = 0):v(_v), cost(_cost){
    }
};
vector<struct Edge>E[MAXN];
bool vis[MAXN];
int dist[MAXN];
void addEdge(int u, int v, int w);
void Dijkstra(int s, int n);
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int t, n, m, c;
    int u, v, w;
    cin>>t;
    for(int C = 1; C <= t; ++C) {
        cin>>n>>m>>c;
        for(int i = 1; i <= 3 * n; ++i) E[i].clear();
        for(int i = 1; i <= n; ++i) {
            cin>>u;
            addEdge(i, n + 2 * u - 1, 0);
            addEdge(n + 2 * u, i, 0);
        }
        for(int i = 1; i < n; ++i) {
            addEdge(n + 2*i - 1, n + 2*(i + 1), c);
            addEdge(n + 2*(i + 1) - 1, n + 2*i, c);
        }
        for(int i = 0; i < m; ++i) {
            cin>>u>>v>>w;
            addEdge(u, v, w);
            addEdge(v, u, w);
        }
        Dijkstra(3*n, 1);
        if(dist[n] == INF) dist[n] = -1;
        cout<<"Case #"<<C<<": "<<dist[n]<<endl;
    }
    return 0;
}
void addEdge(int u, int v, int w)
{
    E[u].push_back(Edge(v, w));
}
void Dijkstra(int s, int n)
{
    for(int i = 0; i <= n; ++i) dist[i] = INF, vis[i] = false;
    priority_queue<qNode> que;
    while(!que.empty()) que.pop();
    dist[s] = 0;
    que.push(qNode(s, 0));
    qNode tmp;
    while(!que.empty()) {
        tmp = que.top();
        que.top();
        int u = tmp.v;
        int Size = E[u].size();
        if(vis[u]) continue;
        vis[u] = true;
        for(int i = 0; i < Size; ++i) {
            int v = E[tmp.v][i].v;
            int cost = E[u][i].cost;
            if(!vis[v] && dist[v] > dist[u] + cost) {
                dist[v] = dist[u] + cost;
                que.push(qNode(v, dist[v]));
            }
        }
    }
}
HerdingCat
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SlidingMenu滑动菜单_4
10-24
SlidingMenu滑动菜单：左右滑动时菜单.写的有点凌乱吗，不过大家仔细看的话肯定会有收获的，里面涉及的东西还是不少的.如有不足的地方，大家可以进行调整.
创新创业大讲堂结课论文：对靳北彪先生《创造论》的一些看法1
08-03
在欧洲文艺复兴时期以及后来的几百年时间里，科学还不是一种职业，大家研究科学或多或少都还是从兴趣出发。那时候研究科学的人要么是本身就是贵族或巨富，像傅里叶和拉瓦锡那样衣食无忧，并不指望着研究科学能给自己...
《百年孤独》
姚军
04-25 1593
读后感： 这是第二次读这本书了，以前读过留下的东西已经比较破碎，这次重新翻阅却是读得比较仔细，也理解得比较深刻。其实从一百年的历史中可以看到，马孔多已经逐渐由封闭到开放，最近从自由党战争和香蕉公司的成立，都在预示着这个落后的地区逐渐走上正轨。但是马孔多并没有独立掌握新兴知识和技术的人，即使在最繁华和热闹的香蕉时代，依旧充当着大浪潮中的跟随者，没有在任何做到引领者，缺乏独立的思想和见解，即使何塞·...
浅谈百年变局下的中国IT走向
三人行必有我师,手写三行必有所悟
07-13 1235
在目前的局面下，中美脱钩论很有市场，中国对于被美国卡脖子的技术进行重构掌握也是一种趋势，但其本质并不是大家看到的美国禁用，我们无法获取到产品和技术才进行自主创造。核心的原因是利益和安全。 安全的因素大家强调的比较多，也是显然的，但这个主要因素是核心原因中比较外层的，更核心的原因还是利益。大家知道，数字化和信息化是未来的趋势，IT软硬件是其载体，其重要性不言而喻。因此为了利益，中国或者中国的企业也必须掌握更底层的硬件或软件，否则，拿不到市场的超额利润，那么在以后的竞争中就会日渐趋弱。因为数字化和信息化的趋势
被人误传了几百年乃至上千年的8句俗话
涂睿的专栏
11-29 1176
 1，“嫁鸡随鸡，嫁狗随狗”，原为“嫁乞随乞，嫁叟随叟”意思是一个女人即使嫁给乞丐或者是年龄大的人也要随其生活一辈子。随着时代的变迁，这一俗语转音成鸡成狗了。 　 2，“三个臭皮匠，顶个诸葛亮”，“皮匠”实际上是“裨将”的谐音，“裨将”在古代是指“副将”，原意是指三个副将的智慧合起来能顶一个诸葛亮。流传中，人们将“裨将”说成了“皮匠”。 　 3，“不见棺材不落泪”，本是“不见亲棺不落泪”，并不是见
父母百年
weixin_30642029的博客
05-07 1797
自传119、在佳木斯上网写作2008年4----出城入城 2008年三月三日我写《花鸟忆出城（七古）》一段宏观调控的博爱状态：假期近水有楼台，月光皎洁自投怀。方知远水难解渴，城外野花并蒂开。东辉天使在人间，遭遇激情戏鸯鸳。阴柔阳刚尽欢乐，灯灭灯明白夜天。东居西迁看楼窗，少儿玩耍未知详。欲进受阻为守秘，水到渠成再入堂。 电影散场十二点，物资有课须紧赶。销约去家唤阿姨，回路相遇两笑脸。课间闻听来人...
《百年孤独》读书笔记
yhl_sophia的博客
03-08 1470
近来大半个月几乎都是阴雨天，我在随处可感知潮湿空气的房间里读完了《百年孤独》。因为是第一遍看，看的很混乱，书中不断重复的人名以及荒诞的情节让我迫切想得知这个百年家族最后的命运，整个阅读过程可以算得上囫囵吞枣了。 也许正是这种模模糊糊的阅读感官，让我读完后隐约能感受到这个百年家族里每个人身上的共同特点 —— 终其一生与孤独奋斗、相伴。所有的阿尔卡蒂奥都是强壮、重视肉欲、有掌控欲...
日本百年企业传承的三个秘诀
05-12 742
导读：韩国央行在2008年发表了一个报告，叫《日本企业长寿的秘密及启示》。在这个报告中认为，全球超过200年以上的企业家大概是五千多家，而日本是三千多家，大概占到了60%。第一章日本总共有420万家企业里面，到底有多少家百年企业？日本经济大学的一位教授，他在《老铺研究》这本书里面认为，日本百年企业实际数量恐怕要超过十万家（编者按：保守数据日本百年企业22000余家，中国1...
硬件工程师要学习的东西
qq_39224344的博客
02-28 2999
硬件工程师要学习的东西 今天，回收参加工作已2个月了，一直出差，修设备的，换个核心板，换个电源之类的。感觉学到东西很少，当初是已硬件工程师助理招进来的。现在都做的啥，基本连续的出差，什么也没学会。这不是坑人吗，想想，自己目前的经济情况，只能寄生于下。但知识，自学是很快的。因此看了些硬件大神的都需要学习那些动西。现在把他们给列出来。 总体，从信号来奋，可以分模拟和数字2类。 模拟的难搞...
《百年孤独》读后感
平和少年的博客
04-06 1020
记不清多久之前曾翻阅过《百年孤独》，没看几页就被冗长的人名、分不清是魔幻还是现实的故事搞得一头雾水，逐渐丧失了继续读下去的兴趣。前几天起早贪黑一口气看完了作者马尔克斯的另一部经典小说《霍乱时期的爱情》，久违的一气呵成、酣畅淋漓的阅读体验，让我升起了爱屋及乌的想法，于是重新买来《百年孤独》，期望这部名气更胜于《霍乱时期的爱情》的世界名著能够为我解锁更多的阅读乐趣，以及阅读之外的沉思与感悟。打开《百年孤独》首页，映入眼帘的是那句被无数人提起过的经典的开场： 多年以后，面对行刑队，奥雷利亚诺·布
吃在深圳+东西冲
小宇宙的专栏
07-21 993
吃在深圳： 探鱼 椰子鸡 来自潮州的牛肉店 店内的牛肉丸和黄牛肉都是必点招牌 推荐理由：牛肉丸作为著名的潮汕小食，在潮汕已有近百年历史，纯手工打造的上好牛肉丸扔在地上能蹦起老高。虽然是潮汕美食，却是深圳街头小吃的绝对主打。这家的牛肉丸牛筋丸超级弹牙，陪牛肉火锅味道一流。更多弹牙多汁的潮汕手打牛肉丸 地址：福田区华强北501栋1楼(近振兴宾馆) 电话：0755-83329089 程
百年科技的历史回顾与哲学反思
人工智能学家
03-24 1537
来源：科学的历程摘要：科学的社会化和社会的科学化是科学的世纪里两个基本的标志。回顾百年科技历程，不只是讲述一个历史故事，更是反省我们当下的处境。19世纪是第一个科学的世纪...
机器人总动员.docx
03-03
时光飞逝，几百年就这样过去了。有一天，一艘飞船降落在地球，一个漂亮的机器人走了出来，开始搜索起什么东西来。瓦力那一成不变的单调生活也从此发生了巨大变化…… 瓦力(WALL·E) 机器人总动员全文共3页，当前为...
world-8:Hyper Island - 探索代码模块 - 简介 10
07-24
“你的家人几代人都按“按钮”来保持阳光照耀，每百年才需要做一次。当你到了十几岁的时候，你对它失去了兴趣，在所有的聚会和旅行之后你完全忘记了你的责任和过程如何按下这个隐藏的（从世界上）按钮。你意识到...
超然楼：明湖风骨
08-19
超然楼是一座位于济南天下第一泉风景区大明湖畔的名楼，始建于元代，拥有几百年历史。楼阁作为中国古代的一种传统建筑，被看作神圣、尊贵和威严的象征。在修建的众多楼阁中，用于观景、赏景的很多，一般临水而建，...
HTML+CSS+JS+JQ+Bootstrap的工业焊接工程服务响应式网页.7z
06-28
探索全栈前端技术的魅力：HTML+CSS+JS+JQ+Bootstrap网站源码深度解析 在这个数字化时代，构建一个既美观又功能强大的网站成为了许多开发者和企业追逐的目标。本份资源精心汇集了一套完整网站源码，融合了HTML的骨架搭建、CSS的视觉美化、JavaScript的交互逻辑、jQuery的高效操作以及Bootstrap的响应式设计，全方位揭秘了现代网页开发的精髓。 HTML，作为网页的基础，它构建了信息的框架；CSS则赋予网页生动的外观，让设计创意跃然屏上；JavaScript的加入，使网站拥有了灵动的交互体验；jQuery，作为JavaScript的强力辅助，简化了DOM操作与事件处理，让编码更为高效；而Bootstrap的融入，则确保了网站在不同设备上的完美呈现，响应式设计让访问无界限。 通过这份源码，你将： 学习如何高效组织HTML结构，提升页面加载速度与SEO友好度； 掌握CSS高级技巧，如Flexbox与Grid布局，打造适应各种屏幕的视觉盛宴； 理解JavaScript核心概念，动手实现动画、表单验证等动态效果； 利用jQuery插件快速增强用户体验，实现滑动效果、Ajax请求等； 深入Bootstrap框架，掌握移动优先的开发策略，响应式设计信手拈来。 无论是前端开发新手渴望系统学习，还是资深开发者寻求灵感与实用技巧，这份资源都是不可多得的宝藏。立即深入了解，开启你的全栈前端探索之旅，让每一个网页都成为技术与艺术的完美融合！
记录一个Mapper坑
06-28
记录一个Mapper坑
260ssm_mysql_jsp 志愿者服务平台.zip（可运行源码+sql文件+文档）
最新发布
06-28
本系统的设计，主要是通过Java语言数据库方面采用MYSQL数据库，采用B/S的设计模式来进行设计开发的。本系统的设计主要是针对此次毕业设计而进行的，只要一台电脑就可以进行开发。其语言的选择和数据库的选择都使用开源且免费的。所以说所开发出来的系统也都是经济可用的。 设计并实现一款基于SSM的志愿者服务平台系统主要其系统包括不同的端组成，前端主要包括系统用户管理、新闻数据管理、变幻图管理、志愿者管理、培训视频管理、志愿者项目管理、服务时长管理、交流分享管理、志愿者表彰管理。前台主要包括网站首页、培训视频、志愿者项目、交流分享、志愿者表彰、新闻信息等。 关键词：Java语言，MySQL数据库，B/S设计模式
基于HTML+CSS+JS开发的网站-运动电商网店响应式网页.7z
06-28
探索全栈前端技术的魅力：HTML+CSS+JS+JQ+Bootstrap网站源码深度解析 在这个数字化时代，构建一个既美观又功能强大的网站成为了许多开发者和企业追逐的目标。本份资源精心汇集了一套完整网站源码，融合了HTML的骨架搭建、CSS的视觉美化、JavaScript的交互逻辑、jQuery的高效操作以及Bootstrap的响应式设计，全方位揭秘了现代网页开发的精髓。 HTML，作为网页的基础，它构建了信息的框架；CSS则赋予网页生动的外观，让设计创意跃然屏上；JavaScript的加入，使网站拥有了灵动的交互体验；jQuery，作为JavaScript的强力辅助，简化了DOM操作与事件处理，让编码更为高效；而Bootstrap的融入，则确保了网站在不同设备上的完美呈现，响应式设计让访问无界限。 通过这份源码，你将： 学习如何高效组织HTML结构，提升页面加载速度与SEO友好度； 掌握CSS高级技巧，如Flexbox与Grid布局，打造适应各种屏幕的视觉盛宴； 理解JavaScript核心概念，动手实现动画、表单验证等动态效果； 利用jQuery插件快速增强用户体验，实现滑动效果、Ajax请求等； 深入Bootstrap框架，掌握移动优先的开发策略，响应式设计信手拈来。 无论是前端开发新手渴望系统学习，还是资深开发者寻求灵感与实用技巧，这份资源都是不可多得的宝藏。立即深入了解，开启你的全栈前端探索之旅，让每一个网页都成为技术与艺术的完美融合！
echarts 柱状图建百年
06-16
创建一个简单的柱状图来表示百年的数据，你可以按照以下步骤操作： 1. 引入ECharts库和CSS样式： ```html <script src="https://cdn.jsdelivr.net/npm/echarts@latest/dist/echarts.min.js"></script> ``` 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值