训练赛二（元素分类，链表，字符串归并）

已于 2022-02-20 09:44:06 修改
阅读量511 收藏
点赞数
分类专栏： 算法题 基础题 文章标签： 链表 哈希 c++ java 贪心算法
于 2022-02-20 09:40:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55296581/article/details/123027095
版权

1.给定一个长度为 nn 的整数数组 a1,a2,…,an。

现在，需要你对数组中的每个元素进行分类。

每个元素要么划分至 b 类，要么划分至 c 类。

我们设所有 b 类元素的相加之和为 sumb，所有 c 类元素的相加之和为 sumc。

请你计算 sumb−sumc 的最大可能值。

如果某类元素的个数为 0，则该类元素的相加之和视为 0。

输入格式

第一行包含整数 n。

第二行包含 n 个整数 a1,a2,…,an。

输出格式

输出一个整数，表示 sumb−sumc 的最大可能值。

数据范围

前三个测试点满足 1≤n≤10。
所有测试点满足 1≤n≤100，−100≤ai≤100。

输入样例1：
3
1 -2 0
输出样例1：
3
输入样例2：
6
16 23 16 15 42 8
输出样例2：
120

思路：贪心

找一个集合最大的，另外一个最小，刚开始认为分别计数大于0，小于等于0即可；后来发现另外一个集合就是0，前面的保证正数相加（跟前面思路类似）

时间复杂度：O(n)

c++代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int n;
int sum1,sum2;
int main()
{
    cin>>n;
    while(n--)
    {
        int x;
        cin>>x;
        if(x>0)sum1+=x;
        else sum2+=x;
    }
    return cout<<sum1-sum2,0;
}

//这样做也行
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

int main()
{
    int n;
    cin >> n;

    int res = 0;
    while (n -- )
    {
        int x;
        cin >> x;
        res += abs(x);
    }

    cout << res << endl;
    return 0;
}

java代码

import java.util.*;
public class Main{
    public static void main(String [] args){
        Scanner cin=new Scanner(System.in);
        int sum1=0,sum2=0;
        int n=cin.nextInt();
        while(n--!=0)
        {
            int x=cin.nextInt();
            if(x>0)sum1+=x;
            else sum2+=x;
        }
        System.out.println(sum1-sum2);
        return ;
    }
}

Python3代码

n = input()
res = list(map(int, input().split()))
print(sum(i if i > 0 else -i for i in res))

2.

有若干个单链表，每个的长度都不小于 2，任意两个链表之间不存在公共节点。

每个节点上都包含一个字符串。

不同节点上包含的字符串不同。

在这些单链表中，包含直接后继节点的节点数量为 q。

给定这 q 个节点的相关信息，请你计算并输出单链表的具体数量以及每个单链表的头节点和尾节点包含的字符串。

输入格式

第一行包含一个整数 q。

接下来 q行，每行描述一个存在直接后继节点的节点的相关信息，包含两个字符串，分别表示该节点包含的字符串以及其直接后继节点包含的字符串。

同一链表中的节点在输入中的相对顺序与在链表中的相对顺序一致。

也就是说，如果节点 a 和节点 b 都在同一链表中，且都存在直接后继节点，那么在输入节点相关信息时，a 节点的信息一定比 b 节点的信息先输入。

输出格式

第一行输出一个整数 n，表示单链表的具体数量。

接下来 n 行，每行输出两个由单个空格隔开的字符串，表示其中一个单链表的头节点和尾节点包含的字符串。

不同链表的输出顺序随意。

数据范围

前三个测试点满足 1≤q≤10。
所有测试点满足 1≤q≤1000，节点字符串由大小写字母和数字组成，长度范围 [1,20]。

思路:       模拟+哈希

时间复杂度：O(n)

c++代码

#include <iostream>
#include <cstring>
#include <algorithm>
#define x first
#define y second
using namespace std;
typedef pair<string, string> PII;
typedef long long LL;
int q;
unordered_map<string,string>mp;
vector<PII>v,ans;
int main()
{
    cin>>q;
    while(q--)
    {
      string a,b;
      cin>>a>>b;
      mp[a]=b;
      v.push_back({a,b});
    }
    for (int i = 0; i < v.size(); i ++ )
    {
       string s=v[i].y;
       if(mp.count(v[i].x))
       {
           while(mp.count(s))
           {
               string temp=s;
               s=mp[s];
               mp.erase(temp);
           }
           ans.push_back({v[i].x,s});
       }
    }
    cout<<ans.size()<<'\n';
    for(auto i:ans)
    {
        cout<<i.x<<' '<<i.y<<'\n';
    }
    //for(auto &[a,b]:ans)
   // {
    //    cout<<a<<' '<<b<<'\n';
    //}
    return 0;
}

//这样做也行
#include <iostream>
#include <cstring>
#include <algorithm>
#include <unordered_map>

using namespace std;

int n;
unordered_map<string, string> head, tail;

int main()
{
    cin >> n;
    while (n -- )
    {
        string a, b;
        cin >> a >> b;
        if (!tail.count(a)) head[a] = b, tail[b] = a;
        else head[tail[a]] = b, tail[b] = tail[a], tail.erase(a);
    }

    cout << head.size() << endl;

    for (auto& [a, b]: head)
        cout << a << ' ' << b << endl;

    return 0;
}

java代码

import java.io.*;
import java.util.*;
public class Main {

    public static void main(String args[])  {
        Scanner cin = new Scanner(System.in);
        int n=cin.nextInt();
        List<String>a=new LinkedList<String>();
        List<String>b=new LinkedList<String>();
        for(int i=0;i<n;i++)
        {
            String s1=cin.next(),s2=cin.next();
            if(b.contains(s1))
            {
                int index=b.indexOf(s1);
                b.set(index,s2);
            }
            else
            {
                a.add(s1);
                b.add(s2);
            }
        }
        int len=a.size();
        System.out.println(len);
        for(int i=0;i<len;i++)
            System.out.println(a.get(i)+" "+b.get(i));
    }
}

Python3代码


def main():
    n = int(input())
    b_a = dict()
    for _ in range(n):
        x, y = input().split()
        if x in b_a:
            a = b_a[x]
            del b_a[x]
            b_a[y] = a
        else:
            b_a[y] = x

    rn = len(b_a)
    print(rn)
    for b, a in b_a.items():
        print("{} {}".format(a, b))

if __name__ == "__main__":
    main()

3.

给定 n 个由小写字母构成的字符串。

现在，请你对它们进行归类。

对于两个字符串 a 和 b：

  • 如果至少存在一个字母在 a 和 b 中同时出现，则 a 和 b 属于同一类字符串。
  • 如果字符串 c 既与字符串 a 同类，又与字符串 b 同类，则 a 和 b 属于同一类字符串。

请问，最终所有字符串被划分为多少类。

输入格式

第一行包含整数 n。

接下来 n 行，每行包含一个仅由小写字母构成的字符串。

注意，输入字符串可能相同。

输出格式

一个整数，表示最终所有字符串被划分为的类的数量。

数据范围

前 6 个测试点满足 1≤n≤10。
所有测试点满足 1≤n≤2×10^5，输入字符串的长度范围 [1,50]，所有输入字符串的总长度范围 [1,106]，所有字符串均由小写英文字母构成。

思路：并查集（合并字母）

看下有几个字母集合即可

c++代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 30;
int n;
int p[N];
bool st[N];
int find(int x)
{
    return p[x]==x?p[x]:p[x]=find(p[x]);
}
int main()
{
    cin>>n;
    for (int i = 0; i < 26; i ++ )p[i]=i;
    while (n -- )
    {
        string s;
        cin>>s;
        int x=find(s[0]-'a');
        st[s[0]-'a']=true;
        for(int i=1;i<s.size();i++)
        {
            st[s[i]-'a']=true;
            int y=find(s[i]-'a');
            if(x!=y)p[y]=x;
        }
    }
    int res=0;
    for (int i = 0; i < 26; i ++ )
        if(st[i]&&p[i]==i)res++;
    return cout<<res,0;
}

//这样做也行
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 200010;

int n;
int p[N];
int id[26];
char str[55];

int find(int x)
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) p[i] = i;

    int res = n;
    for (int i = 1; i <= n; i ++ )
    {
        scanf("%s", str);
        for (int j = 0; str[j]; j ++ )
        {
            int c = str[j] - 'a';
            if (id[c])
            {
                if (find(i) != find(id[c]))
                {
                    p[find(i)] = find(id[c]);
                    res -- ;
                }
            }
            else id[c] = i;
        }
    }

    printf("%d\n", res);
    return 0;
}

java代码

import java.io.*;
import java.util.*;
public class Main {
    static int p[]=new int[26];
    static int ss[]=new int[26];
    public static int find(int x){
        if(p[x]!=x){
            p[x]=find(p[x]);
        }
        return p[x];
    }
    public static void main(String args[])  {
        Scanner cin = new Scanner(System.in);
        int n=cin.nextInt();
        for(int i=0;i<26;i++)p[i]=i;
        for (int i=0;i<n;i++)
        {
            String s=cin.next();
            int x=s.charAt(0)-'a';
            for (char c:s.toCharArray())
            {
                int id=c-'a';
                if(find(id)!=find(x))
                   p[find(id)]=find(x);
                ss[id]=1;
            }
        }
        int ans=0;
        for(int i=0;i<26;i++)
            if(ss[i]>0&&p[i]==i)ans++;
        System.out.println(ans);
        return;
    }
}

欢迎留言点赞

嗷嗷嗷

navy.star
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++递归实例：整数划分问题
glaciet的博客
12-10 844
C++递归实例：整数划分问题
偶在前奇在后排序
hithes的博客
02-09 2082
偶在前奇在后排序 问题描述: 给定N个不同的整数，要求对这N个整数按如下规则排序并输出。 规则一：所有的偶数排在奇数前面。 规则二：在规则一的前提下按照从大到小的顺序排序 输入说明: 数据由两行构成，第一行为整数n（n<=100），表示待排序整数的数量。第二行是n个整数，每个整数的取值区间都为[-32768~32767]，整数之间以空格间隔。 输出说明: 在一行输出排好序的整数，整数之...
4302 元素分类（枚举）
二哈
03-05 145
1. 问题描述： 给定一个长度为 n 的整数数组 a1，a2，…，an。现在，需要你对数组中的每个元素进行分类。每个元素要么划分至 b 类，要么划分至 c 类。我们设所有 b 类元素的相加之和为 sumb，所有 c 类元素的相加之和为 sumc。请你计算 sumb − sumc 的最大可能值。如果某类元素的个数为 0，则该类元素的相加之和视为 0。 输入格式 第一行包含整数 n。第二行包含 n 个整数 a1，a2，…，an。 输出格式 输出一个整数，表示 sumb − sumc 的最大可能值。
【递归】整数划分（C++）
穹的博客
05-24 9073
文章目录一、什么是整数划分二、递归算法实现1. 设计递归方程2. 确定边界条件3. 编写程序代码4. 运行结果展示 一、什么是整数划分 所谓整数划分，是指把一个正整数n写成如下形式： n=m1+m2+⋅⋅⋅+min=m_1+m_2+···+m_in=m1​+m2​+⋅⋅⋅+mi​ 其中mim_imi​为正整数，并且1≤mi≤n1 \leq m_i \leq n1≤mi​≤n，则{m1,m2,⋅⋅⋅,mim_1,m_2,···,m_im1​,m2​,⋅⋅⋅,mi​}为n的一个划分。 如果{m1,m2,⋅⋅
C++数据抽象——对象与类详解
m0_56745306的博客
07-17 409
数据抽象——对象与类 C++对象与类自学笔记，以课本为基础，加了一点自己的改进，并附有相关代码。发布在博客上作为记录，并且勉励自己！ 1.用类定义栈 #include<iostream> using namespace std; class MyStack { public: MyStack() { mytop = NULL; len = 0; }//构造函数 void push(int i); void pop(); int top(); bool isempty();
懒人系列1-基于链表的字符串分割功能实现
最新发布
03-05
本系列为懒人版工具箱，注解丰富，逻辑清晰，移植方便，便于学习和使用，初次上手请参考示例代码。
C语言解字符串逆序和单向链表逆序问题的代码示例
09-02
主要介绍了C语言解字符串逆序和单向链表逆序问题的代码示例,求逆序也是考研和面试中的基础算法题类型,需要的朋友可以参考下
链表字符串.cpp
10-24
链表字符串.cpp
字符串数据结构实现(链表方式)
03-06
字符串数据结构实现(链表方式) 支持中文操作
字符串插入块链实现.zip_块链 串_字符串_链块插入_链表
09-21
输入一串字符串，程序自动分割成8个一串的块链。整个程序通过链表实现，还可实现插入字符串功能。
本题要求编写程序，将给定的n个整数存入数组中，将数组中的这n个数逆序存放，再按顺序输出数组中的元素。
热门推荐
ProceduralMan的博客
03-12 1万+
本题要求编写程序，将给定的n个整数存入数组中，将数组中的这n个数逆序存放，再按顺序输出数组中的元素。
PTA刷题合集（下）
keop123的博客
01-12 2127
本题要求编写程序，将给定的n个整数存入数组中，将数组中的这n个数逆序存放，再按顺序输出数组中的元素。输入在第一行中给出一个正整数n（1≤n≤10）。第二行输入n个整数，用空格分开。在一行中输出这n个整数的处理结果，相邻数字中间用一个空格分开，行末不得有多余空格。
给定一个 n 个元素的数组，再给出 x ，将 x 插入数组第一个位置
相逢既是缘~~
01-14 1188
文章目录一、题目描述二、解题思路三、代码详解 一、题目描述   循环输入。每组数据首先输入一个整数n（n≤10^6）,然后再输入n个整数ai,在输入一个整数x，将x插入数组的第一个位置后，将插入后的数组输出。当没有任何输入时，程序结束。 二、解题思路 本题考查数组的插入。 在数组最后一个数之前插入数据会导致插入位置后面的元素后移，这里我们要用一个临时变量将后移的元素先装起来 将要插入的数和数组中的数（应利用上点说的临时变量）进行交换，实现数组元素的后移。 三、代码详解 #include <s
C++ 算法竞赛中的排序算法
m0_62021646的博客
10-11 2570
本文介绍了算法竞赛中常用的冒泡排序、归并排序、快速排序，并且介绍了C++ STL 中的 sort 函数和 unique 函数。
每日一题-字符串的删减-5
weixin_52243202的博客
08-30 298
给定一个由 n 个小写字母构成的字符串。 现在，需要删掉其中的一些字母，使得字符串中不存在连续三个或三个以上的 x。 请问，最少需要删掉多少个字母？ 如果字符串本来就不存在连续的三个或三个以上 x，则无需删掉任何字母。 输入格式 第一行包含整数 n。 第二行包含一个长度为 n 的由小写字母构成的字符串。 输出格式 输出最少需要删掉的字母个数。 数据范围 3≤n≤100 输入样例1： 6 xxxiii 输出样例1： 1 输入样例2： 5 xxoxx 输出样例2： 0 输入样例3： 10 xxxxxxxxxx
归并排序的简单实现
u011575841的专栏
08-23 311
学习递归最开始就是斐波那契和归并排序。核心思想就是递归地把序列分成两部分，直到只剩一个元素。然后将每次划分的两部分再递归地合并起来，合并时候的顺序觉决定了排序的顺序还是逆序。 划分的过程可以看做是生成一颗叶子结点数为n的二叉树，这个过程的复杂度为lgn（树的高度）。而合并的过程是相当于将每层的节点数相加，复杂度为n*lgn。所以整体的复杂度为O(nlgn)。CLRS里给的复杂度分析方法是递归树（
【非官方题解】2022牛客寒假算法基础集训营5
Wmiracle的博客
02-17 3166
牛客寒假算法基础集训营5非官方题解，记录自己的学习过程，内容为赛时自己的代码加上赛后参考他人代码的总和
贪心算法 洛谷 简单例题题解
Patience
03-19 2915
一、P1090 合并果子 题目描述 在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。 每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1n−1次合并之后， 就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。 因为还要花大力气把这些果子搬回家，...
C++Primer第五版——习题答案详解（二）
weixin_30488313的博客
03-06 169
习题答案目录：https://www.cnblogs.com/Mered1th/p/10485695.html 第3章 字符串、向量和数组 练习3.2 一次读入一整行 #include<iostream> #include<string> using namespace std; int main() { string a; while ...
链表字符串排序
05-28
链表字符串排序可以使用归并排序算法。 具体实现步骤如下： 1. 定义链表节点结构体，包含字符串和指向下一个节点的指针。 2. 定义归并排序函数，输入为链表的头指针，输出为排序后的链表头指针。 3. 在归并排序函数中，先对链表进行分割，直到链表只剩一个节点或为空。 4. 对分割后的链表进行归并，具体实现可以使用双指针法，依次比较两个链表节点的字符串大小，将较小的节点插入到新链表的尾部。 5. 最后返回新链表的头指针即可。 代码实现如下： ``` #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Node { char str[100]; struct Node* next; } Node; Node* merge(Node* l1, Node* l2) { Node* head = (Node*)malloc(sizeof(Node)); Node* cur = head; while (l1 && l2) { if (strcmp(l1->str, l2->str) < 0) { cur->next = l1; l1 = l1->next; } else { cur->next = l2; l2 = l2->next; } cur = cur->next; } cur->next = l1 ? l1 : l2; return head->next; } Node* sortList(Node* head) { if (!head || !head->next) { return head; } Node* slow = head; Node* fast = head->next; while (fast && fast->next) { slow = slow->next; fast = fast->next->next; } Node* mid = slow->next; slow->next = NULL; Node* l1 = sortList(head); Node* l2 = sortList(mid); return merge(l1, l2); } int main() { Node* head = (Node*)malloc(sizeof(Node)); head->next = NULL; int n; printf("Input n: "); scanf("%d", &n); printf("Input strings: "); for (int i = 0; i < n; i++) { char s[100]; scanf("%s", s); Node* node = (Node*)malloc(sizeof(Node)); strcpy(node->str, s); node->next = NULL; Node* cur = head; while (cur->next && strcmp(s, cur->next->str) > 0) { cur = cur->next; } node->next = cur->next; cur->next = node; } head = sortList(head->next); printf("Sorted strings: "); Node* cur = head; while (cur) { printf("%s ", cur->str); cur = cur->next; } return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值