Algorithms

public int sumSqrtCeil(int n, String[] edges){
        ...

        List<Set<Integer>> edgeSetList = "converted first edges element to set of Integer"

        // iterate rest of edges elements -A
        for(int i=1;i<edges.length;i++){

            Set<Integer> nodeDuo = "converted this edges element to set of Integer"

            boolean found = false;
            //search for nodeDuo in set elements of edgeSetList

            //iterate the nodeDuo 2 element set -B
            for(Integer e : nodeDuo){
                //iterate the edgeSetList containing a linked set collection -C
                for (Set<Integer> edgeSet : edgeSetList) {
                    found = edgeSet.contains(e);
                    if (found) {
                        break;
                    }
                }
                if(found) break;
            }

            if(!found){
    
                //if nodeDuo has no element common to any element of edgeSetList then add a new set

                indexOfEdgeSetList++;
                edgeSetList.add(nodeDuo);
            }
            else{
                //else add nodeDuo to the existing set element of edgeSetList in which any of nodeDuo elements were found.
                edgeSetList.get(indexOfEdgeSetList).addAll(nodeDuo);
            }
        }


        Set<Integer> linkedNodes =         //identify a set of all nodes which are linked to a different node(s)

        //Add 1 for each unit nodes (the nodes which are no linked to any other nodes) -D
        for(int i=1;i<=n;i++){
            if(!linkedNodes.contains(i)) output+=1;
        }

        // Add ceil of square root of 'node count' of each linked set in linked nodes set collection -E
        output += edgeSetList.stream().mapToInt(integers -> (int) Math.ceil(Math.sqrt(integers.size()))).sum();
        return output;
    }

Is there any fast algorithm for this:
K people sit at a table. Each person holds a number (hi) which means: some of his neighbour has a cap of height (hi). I want to count the number of combinations for setting people up at the table according to their height of their cups.

Example:

in:
6
2 6 4 5 3 5
out:
2
(We have two combinations which are 1 2 6 4 5 3 and 6 2 1 4 5 3)
Explanation:
We know that first person points on the second person and last person points on the penultimate person. The neighbour of the second person on the left is two, so his neighbour with height 4 should be on the right. Next we know that left neighbour of fifth person is 4, so his neighbour with height 3 should be on the right. We have two combinations to place 1, 6 cups (1,6 and 6, 1):

Visualisation:
2 6 4 5 3 5
X 2 X X 5 X
X 2 X 4 5 3

Possibilities: 1 2 6 4 5 3 or 6 2 1 4 5 3

Any suggestions or help would be greatly appreciated.

 123
Aoo 
Boo
C oo
D  o
E oo

 12345
A oo o
B o  o
Coo
Doo oo
Eo  oo
F  ooo

You need to guess a word. You are provided with a list of Words with the number of character matches at the right position.

Example

input {{"MOXTE",3} , {"AXCDG",0},{"MOQRT",2},{"FOUSE",4},{"POWER",1}}

return "MOUSE"
Explanation:


MOXTE    MO##E    3 matches
AXCDG    #####    0 matches
MOQRT    MO###    2 matches
FOUSE    #OUSE    4 matches
POWER    #O###    1 match

Result:  MOUSE


I tried using brute force. Max heap is not working. Any leads?

1. What is the correct in-order traversal?
   1. U S T X C P Y R B A I G J F N H V T E D L
   2. U S T X C P Y R B A D E I G J F N H V T L
2. What is the correct post-order traversal?
   1. U T S X P R Y C B D I J G N V T H F E L A
   2. U T S X P R Y C B I J G N V T H F E D L A