📌  相关文章
📜  检查是否可以分配值以满足所有给定的关系

📅  最后修改于: 2021-09-07 03:06:34             🧑  作者: Mango

给定一个字符串数组arr[] ,其中每个arr[i]的形式为“i==j”“i!=j” ,其中ij是表示它们之间关系的变量,任务是检查是否可以为满足所有关系的变量赋值。如果发现是真的,则打印“是” 。否则,打印“否”

例子:

方法:解决给定问题的方法是使用联合查找算法。思路是遍历字符串数组,遍历每一个等式关系,对两个变量进行联合运算。遍历之后,去每个字符串中的每个非等式关系,检查两个变量的父变量是否相同。请按照以下步骤解决问题:

  1. 0和一个变量answer初始化一个大小为26的数组parent[]true以存储所需的结果。
  2. 使用变量i遍历数组parent[] ,并将parent[i]设置为i
  3. 现在,遍历每个字符串S字符串的阵列中,并且如果S的值[I] [1]‘=’,然后在S执行联合操作[I] [0 – ‘A’]S [I] [ 3 – ‘a’]
  4. 再次,遍历每个字符串S字符串的阵列中并执行以下操作:
    1. 如果S[i][1] 的值等于‘!’ ,将S[i][0 – ‘a’]S[i][3 – ‘a’]的父节点分别存储在XY 中
    2. 如果X的值等于Y ,则将答案设置为false
  5. 经过上述步骤,如果答案的值为则打印“是”,否则打印“否”

下面是上述方法的实现:

C++
// C++ program for the above approach
#include 
using namespace std;
 
// Function to find parent of each node
int find(int v, vector& parent)
{
    // If parent[v] is not v, then
    // recursively call to find the
    // parent of parent[v]
    if (parent[v] != v)
        return parent[v] = find(parent[v],
                                parent);
 
    // Otherwise, return v
    return v;
}
 
// Function to perform union of the
// two variables
void unions(int a, int b,
            vector& parent)
{
    // Stores the parent of a and b
    int x = find(a, parent);
    int y = find(b, parent);
 
    // If they are not equal, make
    // parent[x] = parent[y]
    if (x != y)
        parent[x] = parent[y];
}
 
// Funtion to check whether it is
// possible to assign values to
// variables to satisfy relations
bool equationsPossible(
    vector& relations)
{
    // Initialize parent array as 0s
    vector parent(26, 0);
 
    // Iterate in range [0, 25]
    // and make parent[i] = i
    for (int i = 0; i < 26; i++) {
        parent[i] = i;
    }
 
    // Store the size of the string
    int n = relations.size();
 
    // Traverse the string
    for (auto string : relations) {
 
        // Check if it is of the
        // form "i==j" or not
        if (string[1] == '=')
 
            // Take union of both
            // the variables
            unions(string[0] - 'a',
                   string[3] - 'a',
                   parent);
    }
 
    // Traverse the string
    for (auto string : relations) {
 
        // Check if it is of the
        // form "i!=j" or not
        if (string[1] == '!') {
 
            // Store the parent of
            // i and j
            int x = find(string[0] - 'a',
                         parent);
            int y = find(string[3] - 'a',
                         parent);
 
            // If they are equal,
            // then return false
            if (x == y)
                return false;
        }
    }
 
    return true;
}
 
// Driver Code
int main()
{
    vector relations
        = { "i==j", "j!=i" };
 
    if (equationsPossible(relations)) {
        cout << "Yes";
    }
    else {
        cout << "No";
    }
 
    return 0;
}


Java
// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
     
// Function to find parent of each node
static int find(int v, ArrayList parent)
{
     
    // If parent[v] is not v, then
    // recursively call to find the
    // parent of parent[v]
    if (parent.get(v) != v)
    {
        parent.set(v, find(parent.get(v), parent));
        return parent.get(v);
    }
     
    // Otherwise, return v
    return v;
}
 
// Function to perform union of the
// two variables
static void unions(int a, int b,
                   ArrayList parent)
{
    // Stores the parent of a and b
    int x = find(a, parent);
    int y = find(b, parent);
     
    // If they are not equal, make
    // parent[x] = parent[y]
    if (x != y)
        parent.set(x, parent.get(y));
}
 
// Funtion to check whether it is
// possible to assign values to
// variables to satisfy relations
static boolean equationsPossible(ArrayList relations)
{
     
    // Initialize parent array as 0s
    ArrayList parent = new ArrayList();
    for(int i = 0; i < 26; i++)
        parent.add(0);
     
    // Iterate in range [0, 25]
    // and make parent[i] = i
    for(int i = 0; i < 26; i++)
    {
        parent.set(i, i);
    }
     
    // Store the size of the string
    int n = relations.size();
     
    // Traverse the string
    for(String str : relations)
    {
     
        // Check if it is of the
        // form "i==j" or not
        if (str.charAt(1) == '=')
         
        // Take union of both
        // the variables
        unions((int)str.charAt(0) - 97,
               (int)str.charAt(3) - 97,
               parent);
    }
     
    // Traverse the string
    for(String str : relations)
    {
     
        // Check if it is of the
        // form "i!=j" or not
        if (str.charAt(1) == '!')
        {
         
            // Store the parent of
            // i and j
            int x = find((int)str.charAt(0) - 97,
                         parent);
            int y = find((int)str.charAt(3) - 97,
                         parent);
             
            // If they are equal,
            // then return false
            if (x == y)
                return false;
        }
    }
    return true;
}
 
// Driver Code
public static void main (String[] args)
{
    ArrayList relations = new ArrayList(
        Arrays.asList("i==j", "j!=i"));
    if (equationsPossible(relations))
    {
        System.out.println("Yes");
    }
    else
    {
        System.out.println("No");
    }
}
}
 
// This code is contributed by rag2127


Python3
# Python3 program for the above approach
 
# Function to find parent of each node
def find(v, parent):
   
    # If parent[v] is not v, then
    # recursively call to find the
    # parent of parent[v]
    if (parent[v] != v):
        parent[v] = find(parent[v], parent)
        return parent[v]
 
    # Otherwise, return v
    return v
 
# Function to perform union of the
# two variables
def unions(a, b, parent):
     
    # Stores the parent of a and b
    x = find(a, parent)
    y = find(b, parent)
 
    # If they are not equal, make
    # parent[x] = parent[y]
    if (x != y):
        parent[x] = parent[y]
 
# Funtion to check whether it is
# possible to assign values to
# variables to satisfy relations
def equationsPossible(relations):
     
    # Initialize parent array as 0s
    parent = [0]*(26)
 
    # Iterate in range [0, 25]
    # and make parent[i] = i
    for i in range(26):
        parent[i] = i
 
    # Store the size of the string
    n = len(relations)
 
    # Traverse the string
    for string in relations:
 
        # Check if it is of the
        # form "i==j" or not
        if (string[1] == '='):
 
            # Take union of both
            # the variables
            unions(ord(string[0]) - ord('a'),ord(string[3]) - ord('a'), parent)
 
    # Traverse the string
    for string in relations:
 
        # Check if it is of the
        # form "i!=j" or not
        if (string[1] == '!'):
 
            # Store the parent of
            # i and j
            x = find(ord(string[0]) - ord('a'), parent)
            y = find(ord(string[3]) - ord('a'), parent)
 
            # If they are equal,
            # then return false
            if (x == y):
                return False
    return True
 
# Driver Code
if __name__ == '__main__':
    relations = ["i==j", "j!=i"]
    if (equationsPossible(relations)):
        print("Yes")
    else:
        print("No")
 
# This code is contributed by mohit kumar 29.


C#
// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
  // Function to find parent of each node
  static int find(int v, List parent)
  {
    // If parent[v] is not v, then
    // recursively call to find the
    // parent of parent[v]
    if (parent[v] != v)
      return parent[v] = find(parent[v],
                              parent);
 
    // Otherwise, return v
    return v;
  }
 
  // Function to perform union of the
  // two variables
  static void unions(int a, int b,
                     List parent)
  {
    // Stores the parent of a and b
    int x = find(a, parent);
    int y = find(b, parent);
 
    // If they are not equal, make
    // parent[x] = parent[y]
    if (x != y)
      parent[x] = parent[y];
  }
 
  // Funtion to check whether it is
  // possible to assign values to
  // variables to satisfy relations
  static bool equationsPossible(List relations)
  {
    // Initialize parent array as 0s
    List parent = new List();
    for(int i=0;i<26;i++)
      parent.Add(0);
 
    // Iterate in range [0, 25]
    // and make parent[i] = i
    for (int i = 0; i < 26; i++) {
      parent[i] = i;
    }
 
    // Store the size of the string
    int n = relations.Count;
 
    // Traverse the string
    foreach( string str in relations) {
 
      // Check if it is of the
      // form "i==j" or not
      if (str[1] == '=')
 
        // Take union of both
        // the variables
        unions((int)str[0] - 97,
               (int)str[3] - 97,
               parent);
    }
 
    // Traverse the string
    foreach (string str in relations) {
 
      // Check if it is of the
      // form "i!=j" or not
      if (str[1] == '!') {
 
        // Store the parent of
        // i and j
        int x = find((int)str[0] - 97,
                     parent);
        int y = find((int)str[3] - 97,
                     parent);
 
        // If they are equal,
        // then return false
        if (x == y)
          return false;
      }
    }
 
    return true;
  }
 
  // Driver Code
  public static void Main()
  {
    List relations = new List{ "i==j", "j!=i" };
 
    if (equationsPossible(relations)) {
      Console.WriteLine("Yes");
    }
    else {
      Console.WriteLine("No");
    }
 
  }
}
 
// This code is contributed by bgangwar59.


输出:
No

时间复杂度: O(N*log M),其中M是 arr[] 中唯一变量的数量。
辅助空间: O(1)

如果您想与行业专家一起参加直播课程,请参阅Geeks Classes Live