If you want efficiency, you could try BEDOPS:

$ bedops --merge A.bed B.bed C.bed > answer.bed

Once you have merged intervals, if you need a list of IDs from intervals that overlap with the merged set, you can use bedmap:

$ bedmap --echo-map-id-uniq answer.bed <(bedops --everything A.bed B.bed C.bed) > ids.txt

I'm not really an R or Granges expert. But I'll describe how you can do the set operations you want to do with BEDOPS tools, which should run quickly.

(I have split my answer into two posts, because of word limits on a single post.)

Let's start with your intervals, which I have relabeled for convenience here:

Let's say the three rows in this figure are BED files called A.bed, B.bed and C.bed. As shorthand, we'll also call these sets A, B and C, containing their respective intervals. Set A has interval A1, A2, A3 and A4. And so on.

Further, let's assume these follow UCSC specification, and the p-value of each element in the BED file for A, B and C is in the file's fifth column, the so-called "score" or "signal" column.

It doesn't matter what you put in the fourth column (ID column), but the score needs to be in the fifth column.

It looks like you want to find the answer to the following questions:

1. What is the smallest p-value interval that overlaps between elements in A and elements in A, B and C?
2. What is the smallest p-value interval that overlaps between elements in B and elements in A, B and C?
3. What is the smallest p-value interval that overlaps between elements in C and elements in A, B and C?

You can use bedmap in BEDOPS to answer this question. This tool maps or makes associations between intervals between two sets based on their overlap. Then you can run operations on those mapped elements.

In this case, you can do score operations with bedmap that give you the lowest scoring element between all mapped overlaps, using the --min-element operation.

Let's start with the first question:

• What is the smallest p-value of intervals that overlap between elements in A and elements in all sets A, B and C?

First, we take the union of sets A, B and C; we'll call this unionABC:

$ bedops --everything A.bed B.bed C.bed > unionABC.bed

Second, we run bedmap to map set A against unionABC. We add the --min-element operand to get the lowest scoring element that overlaps each of intervals A1, A2, A3 and A4, respectively:

$ bedmap --echo --min-element A.bed unionABC.bed > answer_A_vs_unionABC.bed

Let's look at the file answer_A_vs_unionABC.bed line by line. There are four lines, one for each element in A: A1 through A4.

For A1, the elements that overlap A1 from sets A, B and C are: {A1, B1, B2, B3, C1, C2}. We include A1, because an element always overlaps itself. The lowest-scoring element among all of {A1, B1, B2, B3, C1, C2} is A1, with a p-value of 1e-08.

Likewise, for A2, the elements that overlap A2 from sets A, B and C are: {A2, B4, B5, C3, C4}. The lowest-scoring element from this set is A2, with a p-value of 1e-06.

For A3, the elements that overlap A3 from sets A, B and C are: {A3, B6}. The lowest-scoring element is A3: 1e-09.

Finally, for A4, the overlaps are {A4, B8, C6}. The lowest-scoring element is C6: 1e-08.

We can repeat this for the second question:

• What is the smallest p-value of intervals that overlap between elements in B and elements in A, B and C?

We reuse unionABC.bed, but instead of comparing A against this file, we compare B against the union:

$ bedmap --echo --min-element B.bed unionABC.bed > answer_B_vs_unionABC.bed

For element B1, its overlaps are {A1, B1, C1}. The lowest-scoring element is A1: 1e-08.

B2 overlaps {A1, B2, C2}. Again, the lowest-scoring element is A1: 1e-08.

B3 overlaps {A1, B3, C2}. Again, the lowest-scoring element is A1: 1e-08.

B4 overlaps {A2, B4, C3}. The lowest-scoring element is A2: 1e-06.

And so on.

It's the same process for answering the third question:

$ bedmap --echo --min-element C.bed unionABC.bed > answer_C_vs_unionABC.bed

C1 maps to {A1, B1, C1}. The lowest-scoring element is A1: 1e-08.

Etc.

Each line of the answer_* files has two elements in it. The element from the reference set (A, B or C) and the minimum-scoring element from the union set of ABC. These two elements are separated by a pipe (|) character.

You can pass these files to awk to filter them for p-values of interest ("weakly-enriched"), using the pipe character to split the two elements and test if the score column in the second element is between your p-value threshold:

$ awk '\
    function parse_en(eng_num) { \
      split(eng_num,en,/[eEdD]/); return en[1]*10**en[2]; \
    } \
    { \
      n=split($0, elems, "|"); \
      m=split(elems[2], minScoreElem, "\t"); \
      pVal=parse_en(minScoreElem[5]); \ 
      if ((pVal >= 0.000001) && (pVal <= 0.01)) { \
        print $0; \
      } \
    }' answer_A_vs_unionABC.bed > weakly_enriched.answer_A_vs_unionABC.bed

(Awk function to parse scientific notation from here.)

Or you could use a Perl or Python script to do the same — you could even read the file into R and process it there with string parsing functions, though I wouldn't recommend it.

Once you have filtered results for each set, you could figure out what set operations or statistical test you would want to run next to count elements from these results, and then determine if an element is weakly-interacting (or not).

BEDOPS runs fast because it requires that BED files are sorted. Other apps are starting to use sorting to get performance improvements, but I don't know if Granges now uses sorting to make its operations run quickly. In any case, to answer this particular question, BEDOPS bedmap and awk should run very quickly for you.