Buenas noches, tengo un problema en el que basicamente se me pide encontrar la cadena mas larga de vecinos que esten ordenados en donde los elementos adyacentes de una matriz NXN tienen una diferencia de +1.

Ejemplo:  

10  16  15  12
9     8    7   13
2     5    6   14
3     4    1   11

Para la anterior matriz la solucion seria  S = <2,3,4,5,6,7,8,9,10>, se me pide basicamente desarrollar el backtracking pero para llegar al bactracking debo seguir una serie de pasos:
1) Sol recursiva ingenua
2) Memoizacion
3) Bottom-up
4) Backtracking


Mi problema es a la hora de implementar el bottom-up, se supone que debo quitar las recursiones por ciclos para que sea de forma iterativa, sin embargo, no he podido implementarlo de esa forma.

No se si porfa me puedan dar alguna idea para solucionarlo con Bottom-up.

unsigned int naive(vec T, unsigned int i, unsigned int j) {
  unsigned int _max = 0;
  if (T.empty())
    return 0;
  else {
    if (i < T.size() - 1 and T[i][j] == T[i + 1][j] + 1)
      _max = max(_max, naive(T, i + 1, j));
    if (j < T.size() - 1 and T[i][j] == T[i][j + 1] + 1)
      _max = max(_max, naive(T, i, j + 1));
    if (i > 0 and T[i][j] - 1 == T[i - 1][j])
      _max = max(_max, naive(T, i - 1, j));
    if (j > 0 and T[i][j] - 1 == T[i][j - 1])
      _max = max(_max, naive(T, i, j - 1));
  }
  return _max + 1;
}
 

unsigned int memo(vec T, vec &M, unsigned int i, unsigned int j) {
  unsigned int _max = 0;
  if (T.empty())
    return 0;
  if (M[i][j] != 0)
    return M[i][j];
  else {
    if (i < T.size() - 1 and T[i][j] == T[i + 1][j] + 1)
      _max = max(_max, memo(T, M, i + 1, j));
    if (j < T.size() - 1 and T[i][j] == T[i][j + 1] + 1)
      _max = max(_max, memo(T, M, i, j + 1));
    if (i > 0 and T[i][j] - 1 == T[i - 1][j])
      _max = max(_max, memo(T, M, i - 1, j));
    if (j > 0 and T[i][j] - 1 == T[i][j - 1])
      _max = max(_max, memo(T, M, i, j - 1));
    M[i][j] = _max + 1;
  }
 
  return M[i][j];
}
 
 

Las dos implementaciones anteriores son las que hice ingenuamente y con memoizacion

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
 

Routinas

void *routineRead(void *val)
{
    pthread_mutex_lock(&mutex);
    int fg = 0, fd;
    void *buf = malloc(MAX_SIZE * 2);
    do
    {
        fd = open(val, O_RDONLY);
        if (fd == -1)
        {
            perror("pipe");
            printf(" Se volvera a intentar despues\n");
            sleep(5);
        }
        else
            fg = 1;
    } while (fg == 0);
    read(fd, buf, MAX_SIZE * 2);
    close(fd);
    pthread_mutex_unlock(&mutex);
    return buf;
}
void *routineWrite(void *val)
{
    pthread_mutex_lock(&mutex1);
    int fg = 0, fd;
    int *time = malloc(sizeof(int));
    *time = bh.current_time;
    do
    {
        fd = open(val, O_WRONLY);
        if (fd == -1)
        {
            perror("pipe");
            printf(" Se volvera a intentar despues\n");
            sleep(5);
        }
        else
            fg = 1;
    } while (fg == 0);
    write(fd, time, MAX_SIZE);
    close(fd);
    pthread_mutex_unlock(&mutex1);
}
 

Mi proyecto consiste en conectar  dos procesos mediante pipes, un proceso es el controlador y el otro es agente. El controlador basicamente  se encarga de leer del pipe y enviar una respuesta, el punto es que estoy leyendo del pipe a través de un hilo, sin embargo,cada vez que se conecta un agente, el controlador lee el nombre del agente enviado por el agente y luego se crea un fifo que es el fd por donde se comunicaran ellos dos. Vale, el punto es que si llegan el agente1 y el agente2 al mismo tiempo no estoy seguro de lo que pasa pero creo que ambos entra a la sección critica y no me crea el fifo para cada agente sino  que la variable se concatena.

No supe montar la imagen aqui pero en el link pueden ver que es lo que pasa
https://ibb.co/JsgfTp5


Entonces no se  si me puedan ayudar a garantizar que si dos agente o mas se conectan a la vez atienda primero a uno y luego si siga con el otro.

    pthread_t p_read, p_write, p_time;
    sem_init(&sem, 0, 1);
    sem_init(&sem1, 0, 1);
    clean_fifo(pipe);
    int seconds = atoi(argv[6]);
    pthread_create(&p_time, NULL, routineTime, &seconds);
    do
    {
        int cont = 0;
        //p_read get the agent name from the pipe
        pthread_create(&p_read, NULL, routineRead, pipe);
        pthread_join(p_read, (void **)&agent_name);
        printf("Agente:%s\t", agent_name);
        clean_fifo(agent_name);
        //send current time
        pthread_create(&p_write, NULL, routineWrite, pipe);
        pthread_join(p_write, NULL);
        printf("pipe: %s\n", agent_name);
        //Read all the requests by an agent
        do
        {
            pthread_create(&p_read, NULL, routineRead, agent_name);
            pthread_join(p_read, (void **)&data[cont].re);
            if (data[cont].re->amount_people != 0)
                answer_request(&tree, data[cont].re, &bh);
            else
                break;
            write_pipe(fd, (struct Reserva *)data[cont].re, sizeof(Reserva), agent_name, O_WRONLY);
            cont++;
        } while (1);
 
    } while (1);
 

 
#include <stdlib.h>
#include <stdio.h>
void recursive(int number, int *arr, int *i)
{
    arr[*i] = number % 10;
    *i += 1;
    if (number >= 10)
        recursive(number / 10, arr, i);
    else
    {
        //Ordenas el arreglo y corres las posiciones
    }
}
int main(void)
{
    int num = 382731, arr[10], size = 0;
    recursive(num, arr, &size);
    for (int i = size - 1; i >= 0; i--)
        printf("%d", arr[i]);
}
 

Esta es una implementación recursiva, estas obteniendo digito a digito guardandolo en arr , en el else solo debes obtener el mayor e intercambiar posiciones deberias usar un arreglo auxiliar para correr las posiciones.

Espero te sea util 

Para colocar un jugador en cualquier posición solo debes hacer lo siguiente:

tablero[i][j]='v'; //v representa cualquier letra que quieras ponerle
/*
i, representa la fila
j, representa la columna
*/
 

Ten en cuenta que el cero cuenta es decir que la posición tablero[0][0] seria tu primer valor en la matriz.

Otra cosa si J1 y J2 pueden tener una cadena de caracteres,un nombre o algo asi te recomiendo  crear una estructura aparte para facilidad.

typedef struct string
{
     char cadena[1024];
} string;
 

En caso de que en la matriz pueden haber cadenas de caracteres, ya tu matriz no seria de tipo char sino de tipo  struct string.Sin embargo, es más fácil que cada jugador lo representes con una letra para asi diferenciarlos.

Te anexo aqui la solución

#include <iostream>
using namespace std;
#define MAXCHAR 50
struct Grupo
{
    char clave_grupo[50];
};
struct Profesor
{
    struct Grupo lista_grupos[8];
};
int main()
{
    Profesor profesores;
    int num_grup;
    cout << "\nNumero de grupos: ";
    cin >> num_grup;
    cin.ignore();
    for (int i = 0; i < num_grup; i++)
    {
        cout << "Clave del grupo " << i + 1 << ": ";
        cin.getline(profesores.lista_grupos[i].clave_grupo, MAXCHAR);
    }
    return 0;
}
 

En esta linea no estarias almacenando para cada grupo la clave del grupo.

El cin.ignore() se usa para ignorar lo que hay en el bufffer y no salte la lectura de datos .

Hola buenas noches a todos, estoy empezando en el tema de sincronización de procesos a través de semaforos basicamente lo que me piden hacer es que apartir de tres procesos A,B y C tenga como salida ABC ABC ABC utilizando semaforos.

#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <semaphore.h>
sem_t semaphore;
void *routine(void *routine)
{
     for (int i = 0; i < 3; i++)
     {
          sem_wait(&semaphore);
          printf("%s\n", (char *)routine);
          sleep(1);
          sem_post(&semaphore);
     }
}
int main(void)
{
     sem_init(&semaphore, 0, 1);
     pthread_t thread[3];
     pthread_create(&thread[0], NULL, routine, "A");
     pthread_create(&thread[1], NULL, routine, "B");
     pthread_create(&thread[2], NULL, routine, "C");
     for (int i = 0; i < 3; i++)
     {
          pthread_join(thread[i], NULL);
          sleep(1);
     }
}
 

Esa es la implementación que llevo hasta el momento, sin embargo,la salida me es erronea

Esta es mi salida:
AAA BBB CCC

Les agredezco si me pueden ayudar 

Buenas noches comunidad, estoy realizando un arbol general en c que cuenta con una lista génerica para guardar los descendientes(hijos) que hice  en c de forma génerica usando void pointer pero estoy teniendo problemas  .

El problema que me surge ya lo tengo identificado, sin embargo, no se como solucionarlo, lo que pasa es que cuando quiero imprimir un dato del nodo general que se encuentra dentro de la lista me esta saliendo basura, el problema debe ser que estoy realizando mal el cast pero ya intente de varias formas y sigue sin funcionar.

Estructura de la lista

typedef struct node
{
    void *data;
    struct node *next;
} node, Node;
typedef struct list
{
    struct node *head;
 
} list, List;
 
 

Estructura del arbol

typedef struct NodeGeneral
{
    void *data;
    list *dec;
} GeneralNode;
typedef struct GeneralTree
{
    GeneralNode *root;
} GeneralTree;
 

main
En el siguiente código se encuentra el fragmento donde estoy realizando el cast(Linea 12).

int main(void)
{
 
  List *list;
  GeneralNode *proof;
  int x = 5;
  proof = init_GeneralNode((int *)&x);
  init_list(&list, &proof);
  Node *aux = list->head;
  while (aux != NULL)
  {
    GeneralNode *tmp =(GeneralNode *)aux->data; //Aqui estoy realizando el casteo
    printf("::%d\n", *((int *)tmp->data));
    aux = aux->next;
 
  }
 
}
//Las funciones init crean la memoria y establecen los datos
 

Anexó las funciones con las que inicialice la lista y establezco la cabeza(Ya la he probado con diferentes tipos de datos(int,float... datos nativos) y funciona bien la lista)

node *newNode(void *value)
{
    node *newNode = (node *)malloc(sizeof(node));
    newNode->data = value;
    newNode->next = NULL;
    return newNode;
}
void init_list(list **lista, void *value)
{
    list *aux = *lista;
    aux = (list *)malloc(sizeof(list));
    aux->head = newNode(value);
    *lista = aux;
}
//************************************
GeneralNode *init_GeneralNode(void *data)
{
    GeneralNode *newNode = (GeneralNode *)malloc(sizeof(GeneralNode));
    newNode->data = data;
    newNode->dec = NULL;
    return newNode;
}
 

En el NodoGeneral que tengo,en el caso de la lista de descendiente cada dato de la lista representa un NodoGeneral.El next, el puntero al siguiente hijo.

Les agradezco si me pueden ayudar.

Solucionado

Gracias efectivamente ese era el error lo unico que hice fue agregar un parametro para el tamaño y ese lo pasa para el pipe.

void read_pipe(int fd, void *buf, size_t size, char *pipe);
/*
   Reserva msm;
    read_pipe(fd[0], (Reserva *)&msm, sizeof(msm), pipe);
*/
 

Buenos dias , soy nuevo en el lenguaje de c y estoy teniendo problemas a la hora de crear un función génerico para escribir o enviar el pipe.La función  funciona perfectamente sin el génerico pero con el genérico me esta pasando basura y me salta un error Segmentation Fault.

void write_pipe(int fd, void *buf, char *pipe)
{
    int flag = 0, bytes;
    do
    {
        fd = open(pipe, O_WRONLY);
        if (fd == -1)
        {
            perror("pipe");
            printf(" Se volvera a intentar despues\n");
            sleep(5);
        }
        else
            flag = 1;
    } while (flag == 0);
    bytes = write(fd, buf, sizeof(buf));
    printf("Sent it:%d\n", bytes);
    close(fd);
}
void read_pipe(int fd, void *buf, char *pipe)
{
    int flag = 0, bytes;
    do
    {
        fd = open(pipe, O_RDONLY);
        if (fd == -1)
        {
            perror("pipe");
            printf(" Se volvera a intentar despues\n");
            sleep(5);
        }
        else
            flag = 1;
    } while (flag == 0);
    bytes = read(fd, buf, sizeof(buf));
    printf("Received it:%d\n", bytes);
    close(fd);
}
 

>

Y asi llamo la función en el main

 struct data dt;
 write_pipe(fd[0],(struct data*)&dt, argv[8]);