备战

最新推荐文章于 2025-02-26 22:27:57 发布

原创最新推荐文章于 2025-02-26 22:27:57 发布 · 124 阅读

CC 4.0 BY-SA版权

//精度控制 二分
#include<bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
double hs(double x,double y)
{
    return 6*pow(x,7)+8*pow(x,6)+7*pow(x,3)+5*pow(x,2)-y*x;
}
double ds(double x,double y)
{
    return 42*pow(x,6)+48*pow(x,5)+21*pow(x,2)+10*pow(x,1)-y;
}
int main(){
    int a;
    cin>>a;
    while(a--)
    {
        double b,x,y,z;
        cin>>b;
        x = 0.0;
        y = 100.0;
        while(y-x>eps){
        z = (x+y)/2;
        if(ds(z,b)>0){
            y = z;
        }
        else{
            x = z;
        }
        }
        printf("%.4lf\n",hs(z,b));
    }
    return 0;
}

//并查集
#include<bits/stdc++.h>
using namespace std;
int parent[1000];
int res;
int i;
int n,Pair;

int find(int x)
{
    return (x==parent[x])?x:(parent[x]=find(parent[x]));
}
void unite(int x,int y)
{
    x = find(x);
    y = find(y);
    if(x!=y)
    {
        parent[x] = y;
        res--;
    }
}
void init(){
    scanf("%d%d",&n,&Pair);
    res = n;
    for(i=1;i<=n;i++)
    {
        parent[i]=i;
    }
}
int main(){
    int t;
    cin>>t;
    while(t--)
    {
        init();
        for(i=1;i<=pair;i++)
        {
            int num1,num2;
            scanf("%d%d",&num1,&num2);
            unite(num1,num2);
        }
        printf("%d\n",res);
    }
}

//快速幂
long long PowerMod(long long a,long long b,long long c)
{
    int ans = 1;
    a = a%c;
    while(b>0)
    {
        if(b%2==1)
        {
            ans = (ans*a)%c;
        }
        b/=2;
        a =(a*a)%c;
    }
    return ans;
}

//三分求解
#include<bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
//凹函数
double hs(double x,double y)
{
    return 6*pow(x,7)+8*pow(x,6)+7*pow(x,3)+5*pow(x,2)-y*x;
}
int main(){
    int a;
    cin>>a;
    while(a--){
        double l,r,mid,midmid,b;
        cin>>b;
        l = 0.0;
        r = 100.0;
        while(r-l>eps){
            mid = (l+r)/2;
            midmid = (mid+r)/2;
            if(hs(mid,b)>hs(midmid,b))l=mid;
            else r = midmid;
        }
        cout<<hs(mid,b);
    }
    return 0;
}

//自定义优先队列，运算符重载
#include<bits/stdc++.h>
using namespace std;
struct node{
    int x;
    int y;
    friend bool operator <(const node a,const node b){
        if(a.x!=b.x){
            return b.x<a.x;
        }else{
            return b.y>a.y;
        }
    }
    };
int main(){
    priority_queue<node> que;
    node nodeList[6];
    for(int i=1;i<6;i++)
    {
        node newNode;
        newNode.x = i;
        newNode.y = i;
        que.push(newNode);
    }
    node newNode;
    newNode.x = 3;
    newNode.y = 4;
    que.push(newNode);
    while(!que.empty())
    {
        node node1 = que.top();
        que.pop();
        cout<<node1.x<<" "<<node1.y<<endl;
    }

}

//优先队列
#include<bits/stdc++.h>
using namespace std;
int main(){
    priority_queue<int,vector<int>,less<int> >c;//大顶堆，先返回大的
    priority_queue<int,vector<int>,greater<int> >c;//小顶堆，先返回小的
    for(int i=0;i<10;i++)
    {
        c.push(rand());
    }
    while(!c.empty())
    {
        cout<<c.top();
        c.pop();
        cout<<endl;
    }
    return 0;
}

//Dijkstra(迪杰斯特拉)算法求最短路径
//是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。
#include<bits/stdc++.h>
using namespace std;
const int maxn = 10001;
const int inf = 0x3f3f3f3f;
int mapp[maxn][maxn];
int dis[maxn];
int vis[maxn];
int N,M;
void init(){
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=N;j++)
        {
            if(i==j)mapp[i][j]=0;
            else mapp[i][j]=inf;
        }
    }
}
void dijkstra(){
    int flag;
    vis[1]=1;
    for(int i=1;i<=N;i++){
        dis[i]=mapp[1][i];
    }
    for(int i=1;i<=N;i++){
        int minn = inf;
        for(int j=1;j<=N;j++){
            if(!vis[j]&&dis[j]<minn)
            {
                minn = dis[j];
                flag = j;
            }
        }
    //注意在括号外
        vis[flag] = 1;
        for(int v=1;v<=N;v++){
            if(!vis[v]&&dis[v]>vis[flag]+mapp[flag][v])//注意是dis[v]
                dis[v] = dis[flag]+mapp[flag][v];
        }
    }
}
int main(){
    int u,v,w;
    while(~scanf("%d%d",&N,&M))
    {
        if(N==0&&M==0)break;
        memset(vis,0,sizeof(vis));
        init();
        for(int i=1;i<=M;i++)
        {
            cin>>u>>v>>w;
            if(mapp[u][v]>w)
            {
                mapp[u][v]=mapp[v][u]=w;
            }
        }
        dijkstra();
        cout<<dis[N]<<endl;
    }
}

//Floyd算法求最短路径
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1144;
const int inf = 0x3f3f3f3f;
int dis[102][102];
int n,m,a,b;
void init(){
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(i!=j)dis[i][j]=inf;
            else    dis[i][j]=0;
        }
    }
}
void Floyd(int n){
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            for(int k=0;k<n;k++)
            {
                if(dis[j][k]>dis[j][i]+dis[i][k])
                    dis[j][k] = dis[j][i]+dis[i][k];
            }
        }
    }
}
int main(){
    while(~scanf("%d%d",&n,&m))
    {
        int flag=0;
        init();
        while(m--)
        {
            cin>>a>>b;
            dis[a][b] = dis[b][a]=1;
        }
        Floyd(n);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(dis[i][j]>7)
                {
                    flag=1;
                    break;
                }
            }
        }
        if(flag==0)cout<<"Yes"<<endl;
        else       cout<<"No"<<endl;
    }
}

//Kruskal算法求最小生成树
#include<bits/stdc++.h>
using namespace std;
const int maxn = 30;
const int inf = 0x3f3f3f3f;
struct road{
    int st;
    int ed;
    double value;
}roads[80];
int n;
int parent[maxn];
void init()
{
    for(int i=0;i<n;i++)
    {
        parent[i] = i;
    }
}
bool cmp(road a,road b)
{
    if(a.value<b.value)return true;
    else false;
}
int Find(int x)
{
    return (x==parent[x])?x:(parent[x]=Find(parent[x]));
}
bool Merge(int a,int b)
{
    a = Find(a);
    b = Find(b);
    if(a==b)return false;
    else parent[a] = b;
    return true;
}
int Kruskal(int N,int M)//N表示定点数，M表示边数
{
    int num=0;
    int cost=0;
    sort(roads,roads+M,cmp);
    for(int i=0;i<M;i++)
    {
        if(Merge(roads[i].st,roads[i].ed))
        {
            num++;
            cost+=roads[i].value;
        }
        if(num==N-1)break;
    }
    if(num!=N-1)return -1;
    else return cost;
}
int main(){
    while(~scanf("%d",&n))
    {
        if(n==0)break;
        init();
        char s,e;
        int num,cost,k=0;
        for(int i=0;i<n-1;i++)
        {
            cin>>s>>num;
            for(int j=0;j<num;j++,k++)
            {
                cin>>e>>cost;
                roads[k].st = s-'A';
                roads[k].ed = e-'A';
                roads[k].value = cost;
            }
        }
        sort(roads,roads+k,cmp);
        int res = Kruskal(n,k);
        printf("%d\n",res);
    }
    return 0;
}

//Dijkstra+路径记录
#include<bits/stdc++.h>
using namespace std;
const int maxn = 30;
const int inf = 0x3f3f3f3f;
int vis[510];
int mapp[510][510],dis[510];
int money[510][510],cost[510];
int n,m,st,ed;
int pre[510];
vector<int>path;
void dfs(int v)
{
    if(v==st)
    {
        path.push_back(v);
        return;
    }
    dfs(pre[v]);
    path.push_back(v);
}
void dijkstra(int s)
{
    int flag;
    fill(dis,dis+510,inf);
    dis[s] = 0;
    cost[s] = 0;
    for(int i=0;i<n;i++)
    {
        int minn=inf;
        for(int j=0;j<n;j++)
        {
            if(!vis[j]&&dis[i]<minn)
            {
                flag=i;
                minn=dis[i];
            }
        }
        vis[flag]=1;
        for(int i=0;i<n;i++)
        {
            if(!vis[i]&&mapp[flag][i])
            {
                if(dis[i]>dis[flag]+mapp[flag][i])
                {
                    dis[i]=dis[flag]+mapp[flag][i];
                    cost[i]=cost[flag]+money[flag][i];
                    pre[i]=flag;
                }
                else if(dis[i]==dis[flag]+mapp[flag][i])
                {
                    if(cost[flag]+money[flag][i]<cost[i])
                    {
                    cost[i]=cost[flag]+money[flag][i];
                    pre[i]=flag;
                    }
                }
            }
        }
    }
}
int main(){
    cin>>n>>m>>st>>ed;
    for(int i=0;i<m;i++)
    {
        int a,b,c,d;
        cin>>a>>b>>c>>d;
        mapp[a][b]=mapp[b][a]=c;
        money[a][b]=money[b][a]=d;
    }
    dijkstra(st);
    dfs(ed);
    for(int i=0;i<path.size();i++)
    {
        cout<<path[i]<<" ";
    }
    cout<<dis[ed]<<" "<<cost[ed];
}

//完全背包
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int inf = 0x3f3f3f3f;
int dp[25005],v[maxn],n[maxn];
int main(){
    int N;
    while(~scanf("%d",&N)&&N>=0)
    {
        memset(dp,0,sizeof(dp));
        memset(v,0,sizeof(v));
        memset(n,0,sizeof(n));
        int sum = 0;
        for(int i=1;i<=N;i++)
        {
            scanf("%d%d",&v[i],&n[i]);
            sum+=v[i]*n[i];
        }
        int V=sum/2;
        for(int i=1;i<=N;i++)//每一件物品
        {
            for(int k=1;k<=n[i];k++)//件数
            {
                for(int j=V;j>=v[i];j--)//大于这个物品的空间
                {
                    dp[j] = max(dp[j],dp[j-v[i]]+v[i]);
                }
            }
        }
        printf("%d %d\n",sum-dp[V],dp[V]);
    }
}

//0-1背包
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int inf = 0x3f3f3f3f;
int value[maxn];
int dp[250005];
int main(){
    int N;
    int m,n;
    while(scanf("%d",&N)&&N>=0)
    {
        memset(value,0,sizeof(value));
        memset(dp,0,sizeof(dp));
        int item = 0;
        int sum = 0;
        for(int i=0;i<N;i++)
        {
            cin>>m>>n;
            while(n--)
            {
                value[item++]=m;
                sum+=m;
            }
        }
        for(int i=0;i<item;i++)
        {
            for(int j=sum/2;j>=value[i];j--)
            {
                dp[j]=max(dp[j],dp[j-value[i]]+value[i]);
            }
        }
        printf("%d %d\n",sum-dp[sum/2],dp[sum/2]);
    }
    return 0;
}

//素数筛
    memset(isprime,true,sizeof(isprime));
    for(int i=2;i<10001;i++)
    {
        if(isprime[i])
        {
           for(int j=i*2;j<10010;j+=i)
           {
               isprime[j] = false;
           }
        }
    }