一些网络流。

最新推荐文章于 2021-12-11 17:11:08 发布
最新推荐文章于 2021-12-11 17:11:08 发布
阅读量699 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012896700/article/details/37815251
版权

POJ 3281

 题意：每一头牛都有它喜欢吃的食物和饮料，问最多能满足多少头牛 让它吃到它喜欢吃的食物和饮料。


  思路：从源点S对每一个食物连一条边，容量为1， 然后食物对喜欢吃这种食物的牛连边，容量也为1，然后每头牛连一条边到喜欢吃的饮料 容量也为1。

     每个饮料连边到汇点，容量为1。  这样图构好了，但是每头牛可能会产生吃多个食物或者多个饮料的情况，所以对牛这个点也要进行限制。每头牛限制通过的流量为1

   把牛拆成两个点 中间连一条容量为1的边，每个点分别连着食物和饮料，这样求一个最大流就行了。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<iostream>
#define INF 100000000
using namespace std;
struct edge{
   int to;
   int cap;
   int rav;
};
vector<edge> G[808];
int level[808];
int iter[808];
int n,f,d;
void add_edge(int from,int to,int cap)
{
    G[from].push_back((edge){to,cap,G[to].size()});
    G[to].push_back((edge){from,0,G[from].size()-1});
}
void bfs(int s)
{
    queue<int> q;
    memset(level,-1,sizeof(level));
    level[s]=0;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=0;i<G[u].size();i++)
        {
            edge &e=G[u][i];
            if(e.cap>0&&level[e.to]<0)
            {
                level[e.to]=level[u]+1;
                q.push(e.to);
            }
        }
    }
}
int dfs(int v,int t,int f)
{
    if(v==t) return f;
    for(int &i=iter[v];i<G[v].size();i++)
    {
        edge &e=G[v][i];
        if(e.cap>0&&level[v]<level[e.to])
        {
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0)
            {
                e.cap-=d;
                G[e.to][e.rav].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t)
{
    int flow=0;
    while(1)
    {
        bfs(s);
        if(level[t]<0) return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,INF))>0)
            flow+=f;
    }
}
int main()
{
      while(scanf("%d%d%d",&n,&f,&d)!=EOF)
      {
          for(int i=0;i<=(n+n+f+d);i++)
             G[i].clear();
          for(int i=1;i<=f;i++)
            add_edge(0,i,1);
          for(int i=1;i<=n;i++)
          {
              int f1,d1;
              scanf("%d%d",&f1,&d1);
              for(int j=0;j<f1;j++)
              {
                  int p;
                  scanf("%d",&p);
                  add_edge(p,i+f,1);
              }
              add_edge(i+f,i+n+f,1);
              for(int j=0;j<d1;j++)
              {
                  int p;
                  scanf("%d",&p);
                  add_edge(i+n+f,p+n+n+f,1);
              }
          }
          for(int i=1;i<=d;i++)
            add_edge(i+n+n+f,n+n+f+d+1,1);
            int ans;
              int k=2*n+f+d+1;
              ans=max_flow(0,k);
          printf("%d\n",ans);
      }
}



POJ  2135

  题意：一个农夫从1号农田到N号农田 走一个来回 要求不走相同的路且最短。

 思路：建立最小费用流模型，距离为消费，容量为1，然后求1-N流量为2的最小费用就行了。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<iostream>
#define INF 1000000000
using namespace std;
struct edge
{
    int to;
    int cap;
    int cost;
    int rav;
};
vector<edge> G[1005];
int dist[1005];
int n;
int prevv[1005];
int preve[1005];
bool inque[1005];
void add_edge(int from,int to,int cap,int cost)
{
    G[from].push_back((edge){to,cap,cost,G[to].size()});
    G[to].push_back((edge){from,0,-cost,G[from].size()-1});
}
int min_liu(int s,int t,int f)
{
    int res=0;
    while(f>0)
    {
        fill(dist,dist+n,INF);
        memset(inque,0,sizeof(inque));
        dist[s]=0;
        queue<int> q;
        inque[s]=1;
        q.push(s);
        while(!q.empty())
        {
            int u=q.front();
            q.pop();
            inque[u]=0;
            for(int i=0;i<G[u].size();i++)
            {
                edge &e=G[u][i];
                //cout<<u<<" "<<e.to<<" "<<e.cap<<" "<<e.cost<<" "<<dist[e.to]<<" "<<dist[u]+e.cost<<endl;
                if(e.cap>0&&dist[e.to]>dist[u]+e.cost)
                {
                    dist[e.to]=dist[u]+e.cost;
                    prevv[e.to]=u;
                    preve[e.to]=i;
                    if(!inque[e.to])
                    {
                        inque[e.to]=1;
                        q.push(e.to);
                    }
                }
            }
        }
        //cout<<endl;
        if(dist[t]==INF) return -1;
        res+=dist[t];
        for(int v=t;v!=s;v=prevv[v])
        {
            edge &e=G[prevv[v]][preve[v]];
            //cout<<prevv[v]<<endl;
            e.cap--;
            G[v][e.rav].cap++;
            //cout<<v<<" "<<G[v][e.rav].to<<endl;
        }
        f--;
    }
    return res;
}
int main()
{
    int m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=0;i<n;i++)
            G[i].clear();
        while(m--)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a-1,b-1,1,c);
            add_edge(b-1,a-1,1,c);
        }
        printf("%d\n",min_liu(0,n-1,2));
    }

POJ 3686

题意：有一些玩具和一些工厂  每个玩具在不同的工厂加工的时间不同，问平均时间最短多少。

思路：对于一个工厂 如果有k个玩具加工 总时间为T=k*a1+(k-1)*a2+......1*ak;

     我们可以把每个工厂的点拆成N个，每个玩具对第i个工厂的第j个点连边 费用为 j*Zx.表示这个玩具在这个工厂第j个加工。

    然后求一个最小费用就行了。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#define INF 1000000000
using namespace std;
struct edge{
     int to;
     int cap;
     int cost;
     int rav;
};
vector<edge> G[3005];
void add_edge(int from,int to,int cap,int cost)
{
    G[from].push_back((edge){to,cap,cost,G[to].size()});
    G[to].push_back((edge){from,0,-cost,G[from].size()-1});
}
int dist[3005];
bool inque[3005];
int prevv[3005];
int preve[3005];
int min_liu(int s,int t,int f)
{
    int res=0;
    while(f>0)
    {
        queue<int> q;
        fill(dist,dist+t+1,INF);
        dist[s]=0;
        q.push(s);
        inque[s]=1;
        while(!q.empty())
        {
            int u=q.front();
            q.pop();
            inque[u]=0;
            for(int i=0;i<G[u].size();i++)
            {
                edge &e=G[u][i];
                if(e.cap>0&&dist[e.to]>dist[u]+e.cost)
                {
                    dist[e.to]=dist[u]+e.cost;
                    prevv[e.to]=u;
                    preve[e.to]=i;
                    if(!inque[e.to])
                    {
                        inque[e.to]=1;
                        q.push(e.to);
                    }
                }
            }
        }
        if(dist[t]==INF) return -1;
        int d=INF;
        for(int v=t;v!=s;v=prevv[v])
           d=min(d,G[prevv[v]][preve[v]].cap);
        f-=d;
        res+=d*dist[t];
        for(int v=t;v!=s;v=prevv[v])
        {
            edge &e=G[prevv[v]][preve[v]];
            e.cap-=d;
            G[v][e.rav].cap+=d;
        }
    }
    return res;
}
int k[105][105];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        //printf("\n");
        int n,m;
        scanf("%d%d",&n,&m);
        for(int i=0;i<n*m+n+2;i++)
            G[i].clear();
        for(int i=1;i<=n;i++)
            add_edge(0,i,1,0);
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
            scanf("%d",&k[i][j]);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                for(int k1=1;k1<=n;k1++)
                {
                    add_edge(i+1,n+k1+j*n,1,k1*k[i][j]);
                }
            }
        }
        for(int i=n+1;i<=(m+1)*n;i++)
            add_edge(i,(m+1)*n+1,1,0);
        double k=min_liu(0,(m+1)*n+1,n);

        printf("%.6f\n",k/(double)n);
    }
}

POJ 1698

题意： 有一些电影要拍，每个电影只能在特定的星期开拍，并且需要在多少个星期内拍完，问能否拍完。

思路： 每个电影对 他能拍的那一天连边 容量为1。 源点对电影连边 容量为电影需要拍的次数。然后每一天对汇点连边，容量为1，判断最大流是否为电影拍的总和即可。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<vector>
#include<queue>
#include<stack>
#include<math.h>
#include<deque>
#define INF 1000000000
using namespace std;
struct edge{
    int to;
    int cap;
    int rav;
};
vector<edge> G[505];
int level[505];
int iter[505];
void add_edge(int from,int to,int cap)
{
    G[from].push_back((edge){to,cap,G[to].size()});
    G[to].push_back((edge){from,0,G[from].size()-1});
}
void bfs(int s)
{
    queue<int> q;
    q.push(s);
    memset(level,-1,sizeof(level));
    level[s]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=0;i<G[u].size();i++)
        {
            edge &e=G[u][i];
            if(e.cap>0&&level[e.to]<0)
            {
                level[e.to]=level[u]+1;
                q.push(e.to);
            }
        }
    }
}
int dfs(int v,int t,int f)
{
    if(v==t) return f;
    for(int &i=iter[v];i<G[v].size();i++)
    {
        edge &e=G[v][i];
        if(e.cap>0&&level[v]<level[e.to])
        {
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0)
            {
                e.cap-=d;
                G[e.to][e.rav].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t)
{
    int res=0;
    while(1)
    {
        bfs(s);
        if(level[t]==-1) return res;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,INF))>0)
            res+=f;
    }
    return res;
}
bool vis[25][10];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(vis,0,sizeof(vis));
        int n;
        scanf("%d",&n);
        for(int i=0;i<500;i++)
            G[i].clear();
        int l=n+1;
        int ma=0;
        int sum=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<7;j++)
                scanf("%d",&vis[i][j]);
            int f;
            scanf("%d",&f);
            add_edge(0,i+1,f);
            sum+=f;
            int w;
            scanf("%d",&w);
            for(int j=0;j<w;j++)
            {
                for(int k=0;k<7;k++)
                {
                    int s=j*7+k;
                    ma=max(ma,s);
                    if(vis[i][k])
                        add_edge(i+1,l+s,1);
                }
            }
        }
        for(int i=l;i<=ma+l;i++)
            add_edge(i,500,1);
        if(max_flow(0,500)==sum)
            printf("Yes\n");
        else printf("No\n");
    }
}

POJ 2112

题意： 有K个挤奶机和C头牛，每头挤奶机最多只能支持M头牛挤奶，求使得所走路程最远的奶牛路程最短的方案。

思路：先用floyd求点与点之间最短路，源点对每台挤奶机连一条容量为M的边，然后二分路程长度，每次把长度小于等于该长度的边连起来，然后用最大流判断是否可行。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<iostream>
#include<math.h>
#define INF 100000000
using namespace std;
struct edge{
    int to;
    int cap;
    int rav;
};
vector<edge> G[305];
int level[305];
int iter[305];
void add_edge(int from,int to,int cap)
{
    G[from].push_back((edge){to,cap,G[to].size()});
    G[to].push_back((edge){from,0,G[from].size()-1});
}
void bfs(int s)
{
    memset(level,-1,sizeof(level));
    queue<int> q;
    q.push(s);
    level[s]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=0;i<G[u].size();i++)
        {
            edge &e=G[u][i];
            if(e.cap>0&&level[e.to]<0)
            {
                level[e.to]=level[u]+1;
                q.push(e.to);
            }
        }
    }
}
int dfs(int u,int t,int f)
{
    if(u==t) return f;
    for(int &i=iter[u];i<G[u].size();i++)
    {
        edge &e=G[u][i];
        if(e.cap>0&&level[e.to]>level[u])
        {
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0)
            {
                e.cap-=d;
                G[e.to][e.rav].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t)
{
    int res=0;
    while(1)
    {
        bfs(s);
        if(level[t]<0) return res;
        int f;
        memset(iter,0,sizeof(iter));
        while((f=dfs(s,t,INF))>0)
          res+=f;
    }
}
int k[305][305];
void floyd(int n)
{
    for(int k1=0;k1<n;k1++)
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
       {
           k[i][j]=min(k[i][j],k[i][k1]+k[k1][j]);

       }
}
void CLEAR(int l,int r)
{
    for(int i=l;i<=r;i++)
        G[i].clear();
}
int main()
{
    int K,N,M;
    while(scanf("%d%d%d",&K,&N,&M)!=EOF)
    {
        CLEAR(0,K+N+1);
        int n=K+N;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
        {
            scanf("%d",&k[i][j]);
            if(i!=j&&!k[i][j])
                k[i][j]=INF;
        }
        floyd(n);
        int l=0,r=20000;
        int now;
        while(1)
        {
            CLEAR(0,K+N+1);
            for(int i=1;i<=K;i++)
            add_edge(0,i,M);
            for(int i=K+1;i<=n;i++)
            add_edge(i,K+N+1,1);
            now=(l+r)>>1;
            for(int i=0;i<K;i++)
                for(int j=K;j<n;j++)
            {
                if(k[i][j]<=now)
                 add_edge(i+1,j+1,1);
            }
            int f=max_flow(0,n+1);
            //cout<<f<<" "<<now<<endl;
            if(f==N)
            {
                r=now;
            }
            else l=now+1;
            if(l>=r) break;
        }
        printf("%d\n",r);
    }
}


路-过
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
网络流与线性规划24题03最小路径覆盖问题
行走世间，皆为妖怪
03-19 1114
问题描述： 给定有向图G=(V,E)。设P 是G 的一个简单路（顶点不相交）的集合。如果V 中每个 顶点恰好在P 的一条路上，则称P是G 的一个路径覆盖。P 中路径可以从V 的任何一个顶 点开始，长度也是任意的，特别地，可以为0。G 的最小路径覆盖是G 的所含路径条数最少 的路径覆盖。 设计一个有效算法求一个有向无环图G 的最小路径覆盖。 编程任务： 对于给定的给定有向无环图G，编程
网络流之最大流和最小割
Dizzz的博客
02-16 7485
最大流问题最大流：给定有向图中每条边的最大流量（容量），求从源点到汇点的最大流量。容量网络: 括号左边代表容量，右边代表流量。残留网络：流网络中剩余可增加的流量增广路：满足容量条件的一条流量不为零的路径。增广路定理：设容量网络G(V,E)的一个可行流为f，f为最大流的充要条件是在容量网络中不存在增广路。Ford-Fulkson方法：搜索残留网络找增广路，直至找不到增广路（找到最大流）。Edmonds
吃饭【网络流】
stoorz
08-04 248
题目大意： 有nnn头牛，每头牛有自己喜欢的食物和饮料，每种食物或饮料只有一个。求最多能让多少头牛吃到食物并喝到饮料。 InputInputInput 4 3 3 2 2 1 2 3 1 2 2 2 3 1 2 2 2 1 3 1 2 2 1 1 3 3 OutputOutputOutput 3 思路： 很明显的最大流题目。这道题匈牙利会超时，正解是DinicDini...
HDU 3251 Being a Hero
猫ER
12-04 404
题意：国王要给一个英雄一些城市，每个城市可以让这个英雄赚一些钱但是，国王不想到达这个英雄的城市，所以英雄要切断一些路，使得国王到不了这些城市，每条路有相应的拆除费用，问英雄最多可以赚多少钱？ 想法：费用流的思想建边，在残余网络里面找满流边，作为要截取的道路，这些道路 有一个特点，就是一边连着与国王相连的点，一边是英雄的城市。 费用流思想建边：有亏有盈，为了不亏，那么用盈利点的权值来限
一些网络流的题目
Vampire
10-25 1976
bzoj1433假期的宿舍：裸的二分图。 bzoj1412狼和羊的故事：从源点向狼和从羊向汇点连inf的边，再从狼向羊和空格，从空格向空格和羊连1的边，跑最小割就好了。 bzoj1066蜥蜴：很容易可以想到需要拆点。将a拆成a1和a2，从源点向a1(开始时有蜥蜴的各子)连1的边，再从a1向a2连a的高度的边，从a2向b1(a2与b1的距离小于等于d)连a的高度的边，再从a2向汇点连高度的边，跑最
网络流算法
weixin_43226045的博客
05-30 2466
网络流算法 很多实际问题可以建模为流网络 • 装配线上物件的流动 • 电网中电流的流动 • 通信网络中信息的流动 • 道路交通网络中的运输活动 • …… • 一个源节点s、一个汇点t，由源节点流向汇点 • 流量守恒 • 流网络 是一个无自环的有向图G=(V, E)， (1) 图中的每条边(u, v)E有一个非负的容量值c(u, v)0。 if (u, v)E c(u, v)=0； (2) ...
网络最大流
Fuko_Ibuki的博客
03-13 1万+
网络流是什么? 我们要做什么? 三个定理(证明就算了) 如何求最大流 游戏现在开始 Dinic算法 我这个连kmp和rmq都不会的蒟蒻现在才勉强能看懂网络流. 唉. 关于网络流,基础知识很多博客上都有.让我也来扯会淡. 网络流是什么? 考虑以下情景. 假设我家非常有钱(当然是不存在的),自来水厂出的自来水全部都供应我家. 那么必然有很多水管从厂里伸出来,指向我家.水管...
计算机网络重点回顾
热门推荐
weixin_51261234的博客
12-11 14万+
计算机网络 一.计算机网络概述 计算机网络的概念：（*） 1.计算机网络的定义： ​ 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路链接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 2.计算机网络的组成： 终端系统/资源子网：提供共享的软件资源和硬件资源 通信子网：提供信息交换的网络结点和通信线路。 3.计算机网络的类型： 按照拓朴分类： 星型结构 树形结构 总线型结构 环形结构 网状结构 按照范围分
网络流（多样的建模）
Coco_T的博客
10-12 2546
yhzq的总结是非常好的： 网络流总结 然而博主也不是一个只会复制链接的人，还是要有一点自己的感悟的 网络流问题最重要的就是建模和模型转换，下面就给出一些 经典模型 一、最大流 多源多汇问题 源有多个，汇也有多个，流可以从任意源流出，最终可以流向任意汇， 总流量等于所有源流出的总流量（所有汇流入的总流量） 解：加一个超级源点S，和超级汇点T， 从S向每一个源点引一条...
vlc录制网络流_如何使用VLC Media Player录制网络摄像头 | MOS86
weixin_32506617的博客
12-29 2666
VLC是每个计算机用户都必须拥有的应用程序，它的功能不只是播放媒体文件。 以下是如何使用它来记录您的网络摄像头。VLC Media Player是每个Windows用户都应该安装的程序的真实瑰宝。 它最主要的特点是能够播放几乎所有您可以使用的媒体格式。 但是您可能还不知道很多其他功能。 例如，您可以录制您的桌面，将视频从一种格式转换为另一种格式。 今天，我们来看看如何使用VLC录制网络摄像头。首先...
最大网络流Dinic算法
09-01
最大网络流问题在图论和运筹学中占有重要地位，它主要研究在一个有向图中，从源点到汇点能通过的最大流量。Dinic算法是由苏联计算机科学家E. A. Dinic于1970年提出的，是一种解决此类问题的有效算法。该算法基于层的...
网络流24题题解
03-10
虽然没有提供具体的数据包，但我们可以根据通常的网络流题目类型来讨论一些常见的网络流算法和知识点。 1. **最大流问题**：这是网络流最基础的问题，目标是从源节点向汇点传递尽可能多的流量，同时保证不超出每条...
图论与网络流资料.zip
04-06
以下是关于图论与网络流的一些核心概念和应用的详细阐述： 1. **图论基础**： - 图：由顶点（节点）和边组成的数学结构，用于表示对象之间的关系。 - 无向图：边没有方向，两个顶点间可以互相到达。 - 有向图：...
5.有上下界的网络流_有上下界的网络流_
10-03
在网络流模型中，我们还需要关注一些特殊的结构，例如增广路径的存在性、割集（割）的概念以及最小割。割集是图中一部分节点与剩余部分节点之间的边的集合，如果移除割集中所有的边，源节点将无法到达汇点。最小割则...
网络流从入门到入土_MolotovM.pptx
01-27
网络流是一种在图论中的重要概念，特别是在计算机科学和运筹学中有着广泛的应用，例如在运输问题、电路设计、资源分配等领域。本教程“网络流从入门到入土”旨在帮助初学者理解和掌握网络流的基本理论和算法。 首先...
Deep Coral源码（深度相关性学习）
07-25
Deep Coral（深度相关性学习）迁移学习网络资源 Deep Coral是一种先进的迁移学习技术，专注于通过学习源域和目标域之间的相关性来提高模型的泛化能力。这种方法在处理不同数据分布的问题时表现出色，尤其是在无监督领域自适应的场景中。 Deep Coral网络核心特点： 相关性学习 - Deep Coral通过学习源域和目标域特征之间的相关性，减少领域差异，提高模型的泛化能力。 无监督学习 - 该方法无需目标域的标签信息，即可实现有效的领域自适应，适合标签稀缺的场景。 灵活性 - 该网络结构灵活，可以适用于多种不同的迁移学习场景，包括但不限于图像分类、语义分割等。
codeforces round 961 (div. 2)
07-25
A题 思路：对角线上的个数为：n，n-1(2个)，n-2(2个)，n-3(2个),......，1(2个) AC代码： #pragma GCC optimize("O2") #pragma GCC optimize("O3") #include <bits/stdc++.h> using namespace std; #define int long long #define double long double typedef long long ll; typedef unsigned long long ull; typedef pair<int, int> pii; const int N = 1e5 + 5, M = 1e7 + 5, S = 1e6 + 5, inf = 0x3f3f3f3f3f3f3f3f, mod = 1e9 + 7; int n, k; void solve() { cin >> n >> k; vector<int> v; for (int i = n; i >= 1; i--) { if (i
毕业设计：基于Springboot的多媒体信息共享平台
最新发布
07-25
随着信息时代的到来，传统武理多媒体信息共享管理方式的弊端日益显现。针对这些问题，本文分析了传统方式的不足，并采用计算机技术构建武理多媒体信息共享系统。通过查阅相关文献和研究国内外相关技术，本文提出了一种集作品信息管理与信息共享于一体的系统构建方案。 本系统采用B/S架构，结合Spring Boot框架和MySQL数据库技术，针对国内武理多媒体信息共享系统的现状进行开发。系统包含个人中心、用户管理、作品分类管理、作品信息管理、私聊信息管理、系统管理等多个功能模块。经过测试，本系统达到了设计目标，相较于人工管理方式，显著降低了武理多媒体信息共享管理的经济成本，并大幅提升了管理效率。
2022年河南省特岗教师招聘考试题（考生回忆版）.pdf
07-25
2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）.pdf2022年河南省特岗教师招聘考试题（考生回忆版）
网络流问题python
08-02
网络流问题是一种常见的优化问题，可以应用于各种领域，如交通系统、供水管网、金融系统和网络等。在网络流优化问题中，最重要的指标是边的成本和容量限制。常见的网络流问题包括最大流问题、最小费用流问题和最小...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值