Question

我坚持这个问题。我的代码传递了示例中给出的所有测试用例，但代码中存在一些错误。请指出错误。

获得博士学位后，佳士得成为她大学的名人，她的脸谱简介充满了朋友的要求。作为她的好女孩，克里斯蒂接受了所有要求。

现在Kuldeep嫉妒她从其他人那里得到的所有关注，所以他要求她删除她朋友名单中的一些人。为了避免一个场景，科视决定从朋友列表中删除一些朋友，因为她知道每个朋友的受欢迎程度，她使用以下算法删除朋友。

算法删除（朋友）：

        DeleteFriend=false
for i = 1 to Friend.length-1
     if (Friend[i].popularity < Friend[i+1].popularity)
        delete i th friend
        DeleteFriend=true
        break
if(DeleteFriend == false)
    delete the last friend

输入：第一行包含T个测试用例。每个测试用例的第一行包含N，Christie目前拥有的朋友数量和K，即Christie决定删除的朋友数量。接下来的几行包含了她的朋友们在空间分隔时的受欢迎程度。

输出：对于每个测试用例，打印N-K数字，代表克里斯蒂朋友在删除K朋友后的受欢迎程度。

请注意删除完全K朋友后的朋友顺序应按照输入中的说明进行维护。

我的解决方案

    class TestClass {
static class Node
{
    int data;
    Node next;
    Node(int d)
    {
        data = d;
        next = null;
    }}
static Node head = null;
public static void main(String args[] ) throws Exception {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String line = br.readLine();
    int cases = Integer.parseInt(line);
    for (int i = 0; i < cases; i++) {
        line = br.readLine();
        int friends = Integer.parseInt(line);
        line = br.readLine();
        int delete = Integer.parseInt(line);
        head = null;
        Node p =null;
        for(int j=0;j < friends;j++){
            line = br.readLine();
            int temp = Integer.parseInt(line);
            if(head == null){
                head = new Node(temp);
                p = head;
            }
            else{
                Node q = new Node(temp);
                p.next = q;
                p = q;
            }}
        delete_friend(head , delete);
        print_list(head);
    }}
static void delete_friend(Node h, int delete){
    Node p = head;
    Node q = null;
    int flag = 0;
    for (int x = 1; x<=delete;x++){
        p = head;
        flag = 0;
        q = p.next;
        while(p.next != null){
            q = p.next;
            if(p.data < q.data){
                p.data = q.data;
                p.next = q.next;
                flag=1;
                p = head;
                break;
            }
            if (flag == 0 && q.next == null){
                if (p.data >= q.data) {
                    p.next = null;
                    break;
                }}
            p = p.next;
        }}}
static void print_list(Node head){
    Node tnode = head;
    while (tnode != null)
    {
        System.out.print(tnode.data+" ");
        tnode = tnode.next;
    }
    System.out.println();
}}

Answer 1

您阅读输入数据的方式存在缺陷：你的实现假定每行一个整数，但这与问题描述不符：

每个测试用例的第一行包含N，Christie目前拥有的朋友数量和K，即Christie决定删除的朋友数量。接下来的几行包含了她的朋友们在空间分隔时的受欢迎程度。

而不是使用BufferedReader，我建议尝试使用Scanner代替它，它更简单，像这样的东西：

Scanner scanner = new Scanner(System.in);
int t = scanner.nextInt();

for (int i = 0; i < t; i++) {
    int friendsNum = scanner.nextInt();
    int toDeleteNum = scanner.nextInt();

    // ...

    for (int j = 0; j < friendsNum; j++) {
        int current = scanner.nextInt();

        // ...
    }

    // ...
}

修复输入解析后，一些测试将通过。

但是由于不同的问题，超出时间限制，其中许多仍然会失败。这是因为你的算法效率不高。在最坏的情况下，对于每个要删除的朋友，它将迭代直到朋友列表的结尾。

可能有不同的算法：

为每个朋友
- 虽然我们仍然需要删除更多朋友，而且当前的朋友比以前更受欢迎，请删除之前的
- 将当前朋友添加到堆栈
虽然我们仍然需要删除更多朋友，但是从堆栈中移除最后一个

以下是它的内容：

for (int j = 0; j < friendsNum; j++) {
    int current = scanner.nextInt();
    while (deleted < toDeleteNum && !stack.isEmpty() && stack.peek() < current) {
        stack.pop();
        deleted++;
    }
    stack.push(current);
}
while (deleted < toDeleteNum) {
    stack.pop();
    deleted++;
}

Answer 2

如果您可以分享您获得的错误，这将有所帮助。您的br.readLine()正在阅读完整的一行，其中包含要删除的朋友和朋友的数量，并解析它以获得只有朋友数量的错误。尝试使用扫描仪或br.read()一次读取一个输入，看看是否能解决您的问题。

Answer 3

我正在为这个问题得到TLE。我不知道为什么？

https://www.hackerearth.com/problem/algorithm/remove-friends-5/

#include <stdio.h>
#include <stdlib.h>
struct node
{
    int popularity;
    struct node *link;
}*start=NULL;

void delete(struct node **start,int d)
{

     struct node *current = *start;
     struct node *max = *start;
     struct node *temp;

     while (current != NULL && current->link != NULL && d)
     {
         if(current->link->popularity < max->popularity)
         {
             temp = current->link;
             current->link = temp->link;
             free(temp);
             d--;
         }
          else
         {
             current = current->link;
             max = current;
         }
     }

}

struct node* reverse(struct node *root)
{
    struct node *temp;  
    if(root==NULL || root->link==NULL)
        return root;
    temp=reverse(root->link);
    root->link->link=root;
    root->link=NULL;
    return temp;
}

int main()
{
    struct node *tmp,*p;
    int t,n,i,item,k,d;
    scanf("%d",&t);
    while(t--)
    {
        p=start=NULL;
        scanf("%d",&n);
        scanf("%d",&d);
        for(i=0;i<n;i++)
        {
            scanf("%d",&item);
            tmp=(struct node *)malloc(sizeof(struct node));
            tmp->popularity=item;
            tmp->link=NULL;
            if(start==NULL)
                start=tmp;
            else
            {
                p=start;
                while(p->link)
                    p=p->link;
                p->link=tmp;
            }
        }
        start=reverse(start);
        delete(&start,d);
        start=reverse(start);
        p=start;
        while(p!=NULL)
        {
            printf("%d ",p->popularity);
            p=p->link;
        }
        printf("\n");
    }

    return 0;
}

Hackerearth删除好友：运行时错误 - NZEC

3 个答案: