十月天梯赛训练补题 10.31

A - a  HDU - 4442

解题思路：假设有两个队伍a和b，如先去排a，则总体等待时间为：
ax+ax*by+bx,如先去排b,则总体的等待时间为bx+bx*ay+ax。

我们假设a在前优，则：ax*by<ay*bx。由此推广到多个队伍，按照ax*by<ay*bx的标准排序后所得的顺序处理即为答案。

代码：

#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <sstream>
#include <iostream>
#include <algorithm>
//#include <unordered_map>
#define INF 0x3f3f3f3f
#define ll long long
#define ull unsigned long long
#define FILL(a,n,v) fill(a,a+n,v)
#define Mset(a,v) memset(a,v,sizeof a)
#define Mcpy(a,b) memcpy(a,b,sizeof b) //a=b
#define fcio ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
const int mod=365*24*60*60;
const int maxn=1e5+10;
int n;
struct node
{
    ll a;
    ll b;
}arr[maxn];

bool cmp(node a,node b)
{
    return a.a*b.b<b.a*a.b;
}

int main()
{
    while(cin>>n&&n)
    {
        for(int i=0;i<n;i++) cin>>arr[i].a>>arr[i].b;
        sort(arr,arr+n,cmp);
        ll t=0;
        for(int i=0;i<n;i++)
        {
            t+=arr[i].a+t*arr[i].b;
            t%=mod;
        }
        cout<<t<<endl;
    }
}

B - b HDU - 3791 

题意：

给出输入序列判断是否为同一棵二叉搜索树。

代码：

#include <iostream>
#include <queue>
#include <stack>
using namespace std;
const int maxn=1e5+10;;

struct node
{
    int value;
    node *l,*r;

    node()
    {
        this->l=NULL;
        this->r=NULL;
    }

    node(int v)
    {
        this->value=v;
        this->l=NULL;
        this->r=NULL;
    }
};

class binarySearchTree
{
public:
    node* root;
    /**
     二叉搜索树建树
     @a 输入数组 a[0]为根结点
     @n  数组a的长度
     */
    void buildTree(int a[],int n)
    {
        this->root=new node(a[0]);
        for(int i=1;i<n;i++)
        {
            node *now=new node(a[i]);
            node *fa=this->root;
            while(1)
            {
                if(now->value<fa->value)
                {
                    if(fa->l==NULL)
                    {
                        fa->l=now;
                        break;
                    }
                    else fa=fa->l;
                }
                else
                {
                    if(fa->r==NULL)
                    {
                        fa->r=now;
                        break;
                    }
                    else fa=fa->r;
                }
            }
        }
    }
    /**
     层序遍历序列
     返回一个数组
     */
    int* getLevelOrder()
    {
        int* a=new int[maxn];
        int cnt=0;
        queue<node>q;
        q.push(*this->root);
        while(!q.empty())
        {
            node now=q.front();
            a[cnt++]=now.value;
            q.pop();
            if(now.l) q.push(*now.l);
            if(now.r) q.push(*now.r);
        }
        return a;
    }
    /**
     先序遍历序列
     返回一个数组
     */
    int* getPreOrder()
    {
        int* a=new int[maxn];
        int cnt=0;
        node *now=this->root;
        stack<node*>st;
        while(now||st.size())
        {
            while(now)
            {
                a[cnt++]=now->value;
                st.push(now);
                now=now->l;
            }
            if(st.size())
            {
                now=st.top();
                st.pop();
                now=now->r;
            }
        }
        return a;
    }
    /**
     中序遍历序列
     返回一个数组
     */
    int* getInOrder()
    {
        int* a=new int[maxn];
        int cnt=0;
        node *now=this->root;
        stack<node*>st;
        while(now||st.size())
        {
            while(now)
            {
                st.push(now);
                now=now->l;
            }
            if(st.size())
            {
                now=st.top();
                st.pop();
                a[cnt++]=now->value;
                now=now->r;
            }
        }
        return a;
    }
    /**
     后序遍历序列
     返回一个数组
     */
    int* getPostOrder()
    {
        int* a=new int[maxn];
        int cnt=0;
        node* now=this->root;
        stack<node*>st1;
        stack<node*>st2;
        while(now||st1.size())
        {
            while(now)
            {
                st1.push(now);
                st2.push(now);
                now=now->r;
            }
            if(st1.size())
            {
                now=st1.top();
                st1.pop();
                now=now->l;
            }
        }
        while(st2.size())
        {
            now=st2.top();
            st2.pop();
            a[cnt++]=now->value;
        }
        return a;
    }
};

int main()
{
    int n;
    while(cin>>n&&n)
    {
        string s;
        cin>>s;
        int a[maxn];
        int b[maxn];
        for(int i=0;i<s.size();i++) a[i]=s[i]-'0';
        
        binarySearchTree t;
        t.buildTree(a,(int)s.size());
        int* pre1=t.getLevelOrder();
        
        while(n--)
        {
            cin>>s;
            for(int i=0;i<s.size();i++) b[i]=s[i]-'0';
            t.buildTree(b,(int)s.size());
            int* pre2=t.getLevelOrder();
            
            bool flag=true;
            for(int i=0;i<s.size();i++)
            {
                if(pre1[i]!=pre2[i])
                {
                    flag=false;
                    break;
                }
            }
            if(flag) cout<<"YES"<<endl;
            else cout<<"NO"<<endl;
        }
        
        
    }
    
    return 0;
}

E - e  HDU - 5938 

题意：

给定一个字符串s

要求将s分成5个部分 并按顺序+-*/插入 使得最终的值最大

思路：因为有-，所以*和/后的结果要尽可能小，一位数*一位数最大只能是两位数，所以除数就可能为一位数或两位数，如果是三位数，那么会产生小数，从而浪费了前面的加和。还有就是前面相加的两个数可能是所有数+最后一位（相对而言）或第一位+后面的全部。四种情况比较一下大小即可。

#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <sstream>
#include <iostream>
#include <algorithm>
//#include <unordered_map>
#define INF 0x3f3f3f3f
#define ll long long
#define ull unsigned long long
#define FILL(a,n,v) fill(a,a+n,v)
#define Mset(a,v) memset(a,v,sizeof a)
#define Mcpy(a,b) memcpy(a,b,sizeof b) //a=b
#define fcio ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
int n;

string s;
int a[30];

ll solve(int l,int r)
{
    ll ans=0;
    for(int i=l;i<=r;i++)
    {
        ans=ans*10+a[i];
    }
    return ans;
}

int main()
{
    fcio;
    cin>>n;
    for(int k=1;k<=n;k++)
    {
        cin>>s;
        int len=(int)s.size();
        for(int i=0;i<len;i++) a[i]=s[i]-'0';

        ll ans=a[0]+solve(1,len-4)-a[len-3]*a[len-2]/a[len-1];
        ans=max(ans,solve(0,len-5)+a[len-4]-a[len-3]*a[len-2]/a[len-1]);
        if(len>5)
        {
            ll div=solve(len-2,len-1);
            ans=max(ans,a[0]+solve(1,len-5)-a[len-4]*a[len-3]/div);
            ans=max(ans,solve(0,len-6)+a[len-5]-a[len-4]*a[len-3]/div);
        }
        cout<<"Case #"<<k<<": "<<ans<<endl;
    }
}

G - g HDU - 2680 

多起点最短路

代码：

#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <sstream>
#include <iostream>
#include <algorithm>
//#include <unordered_map>
#define INF 0x3f3f3f3f
#define ll long long
#define ull unsigned long long
#define FILL(a,n,v) fill(a,a+n,v)
#define Mset(a,v) memset(a,v,sizeof a)
#define Mcpy(a,b) memcpy(a,b,sizeof b) //a=b
#define fcio ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
const int maxn=1005;

int mp[maxn][maxn];
bool vis[maxn];
int dis[maxn];
int n,m,s;
int u,v,c;

void init()
{
    for(int i=0;i<=n;i++)
    {
        for(int j=0;j<=n;j++)
        {
//            if(i==j) mp[i][j]=0;
//            else mp[i][j]=INF;
            mp[i][j]=INF;
        }
    }
}


void dijkstra(int u)
{
    memset(vis,false,sizeof(vis));
    for(int t=1;t<=n;t++)
    {
        dis[t]=mp[u][t];
    }
    
//    for(int i=1;i<=n;i++) cout<<i<<':'<<dis[i]<<endl;//
    
    vis[u]=true;
    for(int t=1;t<n;t++)
    {
        int minn=INF;
        int temp=0;
        
        for(int i=1;i<=n;i++)
        {
            if(!vis[i]&&dis[i]<minn)
            {
                minn=dis[i];
                temp=i;
            }
        }
        vis[temp]=true;
        for(int i=1;i<=n;i++)
        {
            if(mp[temp][i]+dis[temp]<dis[i])
            {
                dis[i]=mp[temp][i]+dis[temp];
                
//                cout<<temp<<' '<<i<<' '<<dis[i]<<endl;
                
            }
        }
    }
}

int main()
{
    fcio;
    while(cin>>n>>m>>s)
    {
        init();
        while(m--)
        {
            cin>>v>>u>>c;
            mp[u][v]=min(mp[u][v],c);
        }
//        for(int i=1;i<=n;i++)
//        {
//            for(int j=1;j<=n;j++)
//            {
//                cout<<i<<"->"<<j<<": "<<mp[i][j]<<endl;
//            }
//        }
        dijkstra(s);
        
//        for(int i=1;i<=n;i++) cout<<i<<':'<<dis[i]<<endl;
        
        int minn=INF;
        int q;
        cin>>q;
        while(q--)
        {
            int a;
            cin>>a;
            if(dis[a]<minn) minn=dis[a];
        }
        if(minn==INF) cout<<-1<<endl;
        else cout<<minn<<endl;
    }
}

H - h HDU - 1873 

优先队列模版题

代码：

#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <sstream>
#include <iostream>
#include <algorithm>
//#include <unordered_map>
#define INF 0x3f3f3f3f
#define ll long long
#define ull unsigned long long
#define FILL(a,n,v) fill(a,a+n,v)
#define Mset(a,v) memset(a,v,sizeof a)
#define Mcpy(a,b) memcpy(a,b,sizeof b) //a=b
#define fcio ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
int n;

struct node
{
    int num;
    int pri;

    node(int num,int pri)
    {
        this->num=num;
        this->pri=pri;
    }
    bool operator<(const node& a) const
    {
        if(pri!=a.pri) return pri<a.pri;
        else return num>a.num;
    }
};


int main()
{
    while(cin>>n)
    {
        priority_queue<node>q[4];

        string s;
        int i=1;
        for(int k=1;k<=n;k++)
        {
            cin>>s;
            if(s=="IN")
            {
                int a,b;
                cin>>a>>b;
                node pos(i,b);
                q[a].push(pos);
                i++;
            }
            else
            {
                int a;
                cin>>a;
                if(q[a].size())
                {
                    cout<<q[a].top().num<<endl;
                    q[a].pop();
                }
                else  cout<<"EMPTY"<<endl;
            }
        }
    }
}